From 8364ce582dd4b4ff0d753e3efffa4b8675e809bc Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Sat, 21 Feb 2026 10:12:49 -0600 Subject: [PATCH 01/61] Version fix --- CHANGES.rst | 10 ++++++++++ box/__init__.py | 2 +- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/CHANGES.rst b/CHANGES.rst index 07f555f..c4a347d 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Version 7.4.1 +------------- + +* Fixing #303 Wrong version number (7.3.3) in 7.4.0 release (thanks to Michał Górny) + Version 7.4.0 ------------- @@ -11,6 +16,11 @@ Version 7.4.0 * Fixing #291 adding frozen boxes (thanks to m-janicki) * Removing support for Python 3.9 as it is EOL +Version 7.3.3 +------------- + +* Mistakenly released 7.4.0 as 7.3.3 in PyPI, same as above + Version 7.3.2 ------------- diff --git a/box/__init__.py b/box/__init__.py index 8d9d2b5..23ebd2e 100644 --- a/box/__init__.py +++ b/box/__init__.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- __author__ = "Chris Griffith" -__version__ = "7.3.3" +__version__ = "7.4.1" from box.box import Box from box.box_list import BoxList From d079174dd938cbb1b10d5ef38fd12b2dffa0b089 Mon Sep 17 00:00:00 2001 From: Jeroen van Bemmel Date: Tue, 24 Feb 2026 15:51:40 -0600 Subject: [PATCH 02/61] Fix issue #305: Merge dotted keys when non-dotted key with same prefix follows - Add test case for issue #305 documenting the bug - Fix __convert_and_store to merge dict values into existing Box when: - box_dots is enabled - key already exists as a Box (created from dotted keys) - during initialization (__created is False) - This ensures dotted keys like 'a.b: c' are preserved when followed by a non-dotted key like 'a: {d: e}' in YAML files --- box/box.py | 14 ++++++++++++++ test/test_box.py | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+) diff --git a/box/box.py b/box/box.py index 8252643..1b0c961 100644 --- a/box/box.py +++ b/box/box.py @@ -583,6 +583,20 @@ def __convert_and_store(self, item, value): return super().__setitem__(item, value) # This is the magic sauce that makes sub dictionaries into new box objects if isinstance(value, dict): + # If box_dots is enabled and the key already exists as a Box (possibly created from dotted keys), + # merge the new dict into the existing Box instead of overwriting it + # This fixes issue #305 where dotted keys are lost when a non-dotted key with the same prefix comes after + if ( + self._box_config["box_dots"] + and item in self + and isinstance(self[item], Box) + and not self._box_config["__created"] + ): + # Merge the new dict into the existing Box by setting each key-value pair + # This ensures proper conversion of nested structures + for k, v in value.items(): + self[item].__setitem__(k, v) + return # We always re-create even if it was already a Box object to pass down configurations correctly value = self._box_config["box_class"](value, **self.__box_config(extra_namespace=item)) elif isinstance(value, list) and not isinstance(value, box.BoxList): diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..1159fa6 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -369,6 +369,54 @@ def test_from_yaml(self): assert bx.key1 == "value1" assert bx.Key_2 == Box() + def test_from_yaml_box_dots_dotted_key_before_non_dotted(self): + """ + Test for issue #305: Dotted keys read from YAML are lost with box_dots / default_box + when the dotted key appears before a non-dotted key with the same prefix. + + This test documents the bug where a.b: c followed by a: {d: e} causes a.b to be lost. + """ + # Create a temporary YAML file with dotted key before non-dotted key + yaml_content = """a.b: c +a: + d: e +""" + yaml_file = Path(tmp_dir, "test_dotted_before.yml") + yaml_file.write_text(yaml_content) + + # Test without box_dots/default_box - should preserve both keys as separate entries + bx1 = Box.from_yaml(filename=yaml_file) + assert "a.b" in bx1 + assert bx1["a.b"] == "c" + assert "a" in bx1 + assert bx1["a"]["d"] == "e" + + # Test with box_dots=True and default_box=True + # Expected behavior: a.b should be merged into a.b, so a.b == "c" and a.d == "e" + # Current bug: a.b is lost when it appears before a: + bx2 = Box.from_yaml(filename=yaml_file, box_dots=True, default_box=True) + assert "a" in bx2 + assert bx2["a"]["d"] == "e" + # This assertion will fail until the bug is fixed: + # The dotted key a.b should be accessible as either a["b"] or via dotted notation + assert "b" in bx2["a"], "Bug #305: a.b key is lost when it appears before a: in YAML" + assert bx2["a"]["b"] == "c" + + # Test reverse order (non-dotted before dotted) - this should work correctly + yaml_content_reverse = """a: + d: e +a.b: c +""" + yaml_file_reverse = Path(tmp_dir, "test_dotted_after.yml") + yaml_file_reverse.write_text(yaml_content_reverse) + + bx3 = Box.from_yaml(filename=yaml_file_reverse, box_dots=True, default_box=True) + assert "a" in bx3 + assert bx3["a"]["d"] == "e" + # In reverse order, the dotted key should be properly merged + assert "b" in bx3["a"] + assert bx3["a"]["b"] == "c" + def test_bad_from_json(self): with pytest.raises(BoxError): Box.from_json() From bd8ef9468130747bf090a38e5d8e2fcff2366423 Mon Sep 17 00:00:00 2001 From: kigland Date: Sat, 30 May 2026 03:13:31 +0800 Subject: [PATCH 03/61] Preserve the Box subclass for nested boxes after unpickling Box.__init__ derives box_class from self.__class__, but Box.__new__ hardcoded the base Box. Unpickling calls __new__ + __setstate__ (not __init__), so a subclass instance ended up with box_class=Box, and nested boxes created on access after unpickling became base Box instead of the subclass. Use cls in __new__ to match __init__. --- box/box.py | 2 +- test/test_box.py | 15 +++++++++++++++ 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/box/box.py b/box/box.py index 8252643..f1d7840 100644 --- a/box/box.py +++ b/box/box.py @@ -233,7 +233,7 @@ def __new__( "box_recast": box_recast, "box_dots": box_dots, "box_dots_exclude": re.compile(box_dots_exclude) if box_dots_exclude else None, - "box_class": box_class if box_class is not None else Box, + "box_class": box_class if box_class is not None else cls, "box_namespace": box_namespace, } ) diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..c5896ad 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -32,6 +32,10 @@ from box.converters import BOX_PARAMETERS +class _SubclassBox(Box): + """Module-level Box subclass so its instances are picklable in tests.""" + + def mp_queue_test(q): bx = q.get() try: @@ -686,6 +690,17 @@ def test_pickle(self): assert bx == loaded2 loaded2.box_options = bx.box_options + def test_pickle_preserves_subclass_on_nested_access(self): + if platform.python_implementation() == "PyPy": + pytest.skip("Pickling does not work correctly on PyPy") + # Unpickling goes through __new__ + __setstate__ but not __init__, so + # box_class must be set from cls in __new__ too. Otherwise nested boxes + # created on access after unpickling fall back to the base Box (#308). + b = _SubclassBox({"a": {"b": 1}}) + loaded = pickle.loads(pickle.dumps(b)) + assert isinstance(loaded, _SubclassBox) + assert type(loaded.a) is _SubclassBox + def test_pickle_default_box(self): if platform.python_implementation() == "PyPy": pytest.skip("Pickling does not work correctly on PyPy") From 22d94db8bee027319cc56592d93f7755f4b3a267 Mon Sep 17 00:00:00 2001 From: Vincent Gao Date: Sat, 20 Jun 2026 15:02:47 +0200 Subject: [PATCH 04/61] fix: preserve existing keys on dotted list writes BoxList.__setitem__ unconditionally replaced the element at the target index with a fresh empty container before recursing, so a second dotted write into an existing element (a[0].y after a[0].x) discarded the keys already stored there. Only replace the element when it is not already the right container type, matching the guard in Box.__setitem__. --- box/box_list.py | 10 ++++++++-- test/test_box_list.py | 18 ++++++++++++++++++ 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/box/box_list.py b/box/box_list.py index 72609ff..819c205 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -106,9 +106,15 @@ def __setitem__(self, key, value): return super().__setitem__(pos, value) children = key[len(list_pos.group()) :].lstrip(".") if self.box_options.get("default_box"): + # Only replace the element at ``pos`` with a fresh container when it is + # not already the right one; otherwise a second dotted write into an + # existing element (e.g. ``a[0].y`` after ``a[0].x``) would discard the + # data already stored there. Mirrors the guard in Box.__setitem__. + current = super().__getitem__(pos) if children[0] == "[": - super().__setitem__(pos, box.BoxList(**self.box_options)) - else: + if not isinstance(current, box.BoxList): + super().__setitem__(pos, box.BoxList(**self.box_options)) + elif not isinstance(current, box.Box): super().__setitem__(pos, self.box_options.get("box_class")(**self.box_options)) return super().__getitem__(pos).__setitem__(children, value) super().__setitem__(key, value) diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e0..0fd7de8 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -241,6 +241,24 @@ def test_box_list_default_dots(self): box_3["a.b[0]"] = 42 assert box_3.a.b[0] == 42 + # A second dotted write into an existing list element must not discard + # the keys already written there (regression). + box_4 = Box(default_box=True, box_dots=True) + box_4["a[0].x"] = 1 + box_4["a[0].y"] = 2 + assert box_4.a[0].to_dict() == {"x": 1, "y": 2} + + box_5 = Box(default_box=True, box_dots=True) + box_5["a[0][0].x"] = 1 + box_5["a[0][1].y"] = 2 + assert box_5.a[0].to_list() == [{"x": 1}, {"y": 2}] + + # A scalar already at the position is still overwritten. + box_6 = Box(default_box=True, box_dots=True) + box_6["a[0]"] = 5 + box_6["a[0].x"] = 1 + assert box_6.a[0].to_dict() == {"x": 1} + def test_box_config_propagate(self): structure = Box(a=[Box(default_box=False)], default_box=True, box_inherent_settings=True) assert structure._box_config["default_box"] is True From 70b3567a0910e9f570750885eacba232bba7e701 Mon Sep 17 00:00:00 2001 From: Vincent Gao Date: Wed, 24 Jun 2026 10:21:20 +0200 Subject: [PATCH 05/61] fix: case-insensitive ConfigBox key lookup for __getitem__, __contains__, __delitem__, __setitem__ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ConfigBox docstring advertises "loosey goosey" case-insensitive access but __getitem__ (dict-style), __contains__, __delitem__ and __setitem__ had no case-insensitive support. __getattr__ only retried with lowered input, missing MixedCase→lowercase resolution. Add _case_insensitive_key() helper and override the four dunder methods to resolve keys case-insensitively. __getattr__ now uses the same key-scan fallback instead of the broken .lower() retry. --- box/config_box.py | 39 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 38 insertions(+), 1 deletion(-) diff --git a/box/config_box.py b/box/config_box.py index 5f8ad55..3715085 100644 --- a/box/config_box.py +++ b/box/config_box.py @@ -20,6 +20,15 @@ class ConfigBox(Box): _protected_keys = dir(Box) + ["bool", "int", "float", "list", "getboolean", "getfloat", "getint"] + @staticmethod + def _case_insensitive_key(keys, item): + """Return a matching key (case-insensitive) from *keys*, or *item* if no match.""" + lower = item.lower() + for k in keys: + if k.lower() == lower: + return k + return item + def __getattr__(self, item): """ Config file keys are stored in lower case, be a little more @@ -28,7 +37,35 @@ def __getattr__(self, item): try: return super().__getattr__(item) except AttributeError: - return super().__getattr__(item.lower()) + # Try case-insensitive match across all keys, not just lowering input + matched = self._case_insensitive_key(self.keys(), item) + if matched != item: + return super().__getattr__(matched) + raise + + def __getitem__(self, item, _ignore_default=False): + try: + return super().__getitem__(item, _ignore_default=_ignore_default) + except KeyError: + matched = self._case_insensitive_key(self.keys(), item) + if matched != item: + return super().__getitem__(matched, _ignore_default=_ignore_default) + raise + + def __contains__(self, item): + if super().__contains__(item): + return True + return self._case_insensitive_key(self.keys(), item) != item + + def __setitem__(self, key, value): + matched = self._case_insensitive_key(self.keys(), key) + if matched != key: + key = matched + super().__setitem__(key, value) + + def __delitem__(self, key): + matched = self._case_insensitive_key(self.keys(), key) + super().__delitem__(matched) def __dir__(self) -> list[str]: return super().__dir__() + ["bool", "int", "float", "list", "getboolean", "getfloat", "getint"] From e7c2989bb49e1e5e5c3882ebdd30df30f52d3160 Mon Sep 17 00:00:00 2001 From: apoorvdarshan Date: Sun, 5 Jul 2026 00:20:23 +0530 Subject: [PATCH 06/61] Fix serialization of frozen_box with nested lists frozen_box stores lists as tuples of Boxes for immutability, but Box.to_dict() only recursed into Box and BoxList values -- not tuples -- so the nested Boxes were left unconverted. to_yaml() then failed with RepresenterError since ruamel can't represent a Box. Recurse into tuples in to_dict(), converting nested Box/BoxList members back to native types while preserving the tuple. Fixes #272. --- CHANGES.rst | 5 +++++ box/box.py | 21 +++++++++++++++++++++ test/test_box.py | 16 ++++++++++++++++ 3 files changed, 42 insertions(+) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..93844a0 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Fixing #272 ``frozen_box`` with nested lists could not be serialized to YAML (thanks to apoorvdarshan) + Version 7.4.1 ------------- diff --git a/box/box.py b/box/box.py index 8252643..d982d99 100644 --- a/box/box.py +++ b/box/box.py @@ -97,6 +97,25 @@ def _recursive_tuples(iterable, box_class, recreate_tuples=False, **kwargs): return tuple(out_list) +def _to_native_tuple(iterable): + """Convert a tuple's Box/BoxList members back to native types. + + ``frozen_box`` stores lists as tuples of Boxes, so ``to_dict`` needs to + turn those nested Boxes back into plain dicts to remain serializable. + """ + out_list = [] + for i in iterable: + if isinstance(i, Box): + out_list.append(i.to_dict()) + elif isinstance(i, box.BoxList): + out_list.append(i.to_list()) + elif isinstance(i, tuple): + out_list.append(_to_native_tuple(i)) + else: + out_list.append(i) + return tuple(out_list) + + def _parse_box_dots(bx, item, setting=False): for idx, char in enumerate(item): if char == "[": @@ -815,6 +834,8 @@ def to_dict(self) -> dict: out_dict[k] = v.to_dict() elif isinstance(v, box.BoxList): out_dict[k] = v.to_list() + elif isinstance(v, tuple): + out_dict[k] = _to_native_tuple(v) return out_dict def update(self, *args, **kwargs): diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..56dcfe2 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -435,6 +435,22 @@ def test_frozen(self): assert hash(bx3) + def test_frozen_box_with_lists_is_serializable(self): + # frozen_box stores lists as tuples of Boxes; to_dict must convert the + # nested Boxes back to native dicts so serialization works. See #272. + bx = Box({"a": [{"b": 123}, {"b": 222}], "c": [[{"d": 2}], [3, 4]]}, frozen_box=True) + + native = bx.to_dict() + assert isinstance(native["a"], tuple) + assert native["a"][0] == {"b": 123} + assert not isinstance(native["a"][0], Box) + assert not isinstance(native["c"][0][0], Box) + + # These used to raise RepresenterError / serialization errors. + yaml = YAML(typ="safe") + assert yaml.load(bx.to_yaml()) == {"a": [{"b": 123}, {"b": 222}], "c": [[{"d": 2}], [3, 4]]} + assert json.loads(bx.to_json()) == {"a": [{"b": 123}, {"b": 222}], "c": [[{"d": 2}], [3, 4]]} + def test_hashing(self): bx1 = Box(t=3, g=4, frozen_box=True) bx2 = Box(g=4, t=3, frozen_box=True) From 83031a8b837bd99e7ec012efb20da25553fe713a Mon Sep 17 00:00:00 2001 From: chuenchen309 <48723787+chuenchen309@users.noreply.github.com> Date: Mon, 20 Jul 2026 06:14:32 +0800 Subject: [PATCH 07/61] Preserve box options in BoxList.__deepcopy__ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `BoxList.__deepcopy__` built the copy as `self.__class__()` with no `box_options`, so `copy.deepcopy()` silently dropped every option (`frozen_box`, `box_dots`, `default_box`, `box_intact_types`, …). A frozen BoxList became mutable (and unhashable) after a deepcopy. `BoxList.__copy__` and `Box.__deepcopy__` both preserve options; `BoxList.__deepcopy__` was the outlier. Mirror `Box.__deepcopy__`: build unfrozen, register in memo before recursing (keeps cycle-safety), populate, then re-freeze via `__init__`. --- box/box_list.py | 5 ++++- test/test_box_list.py | 22 ++++++++++++++++++++++ 2 files changed, 26 insertions(+), 1 deletion(-) diff --git a/box/box_list.py b/box/box_list.py index 72609ff..6dd6509 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -169,11 +169,14 @@ def __copy__(self): return self.__class__((x for x in self), **self.box_options) def __deepcopy__(self, memo=None): - out = self.__class__() + frozen = self.box_options.get("frozen_box") + out = self.__class__(**{**self.box_options, "frozen_box": False}) memo = memo or {} memo[id(self)] = out for k in self: out.append(copy.deepcopy(k, memo=memo)) + if frozen: + out.__init__(**self.box_options) return out def __hash__(self) -> int: # type: ignore[override] diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e0..71067c3 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -74,6 +74,28 @@ def test_frozen_list(self): bl2[1] = 4 assert bl2[1] == 4 + def test_deepcopy_preserves_box_options(self): + import copy + + # deepcopy must preserve box_options, matching __copy__ and Box.__deepcopy__ + for options in ( + {"frozen_box": True}, + {"box_dots": True}, + {"default_box": True}, + {"box_intact_types": (dict,)}, + ): + bl = BoxList([{"a": 1}], **options) + key = list(options)[0] + assert copy.copy(bl).box_options.get(key) == options[key] + assert copy.deepcopy(bl).box_options.get(key) == options[key] + + # a frozen BoxList must stay frozen (immutable + hashable) after deepcopy + frozen = BoxList([5, 4, 3], frozen_box=True) + clone = copy.deepcopy(frozen) + with pytest.raises(BoxError): + clone.append(1) + assert hash(clone) == hash(frozen) + def test_box_list_to_json(self): bl = BoxList([{"item": 1, "CamelBad": 2}]) assert json.loads(bl.to_json())[0]["item"] == 1 From 1fb782d56e2364688350ac219e1c5ce75e3d5701 Mon Sep 17 00:00:00 2001 From: tan_unique <143566827+vinson0522@users.noreply.github.com> Date: Fri, 14 Aug 2026 07:59:10 +0000 Subject: [PATCH 08/61] Convert ruamel YAML scalars to builtin types on load --- box/converters.py | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/box/converters.py b/box/converters.py index bb91ba6..d072cd5 100644 --- a/box/converters.py +++ b/box/converters.py @@ -233,6 +233,30 @@ def _to_yaml( raise BoxError(MISSING_PARSER_ERROR) + +def _ruamel_to_builtin(obj): + """Convert ruamel.yaml scalar types to plain Python builtins. + + ScalarFloat/ScalarInt survive Box.to_dict() and break serializers + that only accept builtin float/int (issue #264). + """ + if isinstance(obj, dict): + return {k: _ruamel_to_builtin(v) for k, v in obj.items()} + if isinstance(obj, list): + return [_ruamel_to_builtin(v) for v in obj] + module = type(obj).__module__ + if module.startswith("ruamel"): + if isinstance(obj, bool): + return bool(obj) + if isinstance(obj, int): + return int(obj) + if isinstance(obj, float): + return float(obj) + if isinstance(obj, str): + return str(obj) + return obj + + def _from_yaml( yaml_string: str | None = None, filename: str | PathLike | None = None, @@ -272,7 +296,7 @@ def _from_yaml( raise BoxError(MISSING_PARSER_ERROR) else: raise BoxError("from_yaml requires a string or filename") - return data + return _ruamel_to_builtin(data) def _to_toml(obj, filename: str | PathLike | None = None, encoding: str = "utf-8", errors: str = "strict"): From 41f83c32558ffa9223d248a9cb1a48660312c52e Mon Sep 17 00:00:00 2001 From: tan_unique <143566827+vinson0522@users.noreply.github.com> Date: Fri, 14 Aug 2026 07:59:11 +0000 Subject: [PATCH 09/61] Test from_yaml returns builtin float/int/bool --- test/test_box.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..7f8f562 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -369,6 +369,17 @@ def test_from_yaml(self): assert bx.key1 == "value1" assert bx.Key_2 == Box() + + def test_from_yaml_builtin_scalars(self): + bx = Box.from_yaml("Float: 0.1\nCount: 4\nFlag: true\n") + assert type(bx.Float) is float + assert type(bx.Count) is int + assert type(bx.Flag) is bool + dumped = bx.to_dict() + assert type(dumped["Float"]) is float + assert type(dumped["Count"]) is int + assert dumped["Float"] == 0.1 + def test_bad_from_json(self): with pytest.raises(BoxError): Box.from_json() From a7d3f152ed048719229d19d16e6d170cff896c39 Mon Sep 17 00:00:00 2001 From: tan_unique <143566827+vinson0522@users.noreply.github.com> Date: Fri, 14 Aug 2026 07:59:12 +0000 Subject: [PATCH 10/61] Note #264 ScalarFloat fix in changelog --- CHANGES.rst | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..829d9a3 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Version 7.4.2 +------------- + +* Fixing #264 ruamel.yaml ScalarFloat/ScalarInt kept as non-builtin types after from_yaml + Version 7.4.1 ------------- From b998cc4df20f9c16f2230a4c2b1193646dc938d2 Mon Sep 17 00:00:00 2001 From: SeaStar Deng <37767638+DSeaStar@users.noreply.github.com> Date: Fri, 14 Aug 2026 16:32:14 +0000 Subject: [PATCH 11/61] Fix nested boxes losing box_dots after pickle Pickle assigns items before __setstate__, so nested Box objects were recreated with default options and dotted lookups failed after load. --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ box/box.py | 11 +++++++++++ test/test_box.py | 31 +++++++++++++++++++++++++++++++ 4 files changed, 48 insertions(+) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..bc8358c 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,7 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- DSeaStar (DSeaStar) Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..9a5d706 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Version 7.4.2 +------------- + +* Fixing #260 nested boxes lose ``box_dots`` (and other options) after pickle (thanks to DSeaStar) + Version 7.4.1 ------------- diff --git a/box/box.py b/box/box.py index 8252643..42698a8 100644 --- a/box/box.py +++ b/box/box.py @@ -237,6 +237,10 @@ def __new__( "box_namespace": box_namespace, } ) + # Pickle reconstructs via __new__ + item assignment + __setstate__. + # Item assignment happens first, while this Box still has default options, + # so nested Box/BoxList values must be stored as-is (see __convert_and_store). + obj._box_config["__unpickling"] = True return obj def __init__( @@ -491,6 +495,8 @@ def __deepcopy__(self, memodict=None) -> Box: def __setstate__(self, state): self._box_config = state["_box_config"] self.__dict__.update(state) + self._box_config["__created"] = True + self._box_config["__unpickling"] = False def __process_dotted_key(self, item): if self._box_config["box_dots"] and isinstance(item, str): @@ -581,6 +587,11 @@ def __convert_and_store(self, item, value): # If the value has already been converted or should not be converted, return it as-is if self._box_config["box_intact_types"] and isinstance(value, self._box_config["box_intact_types"]): return super().__setitem__(item, value) + # Pickle sets items before __setstate__, so this Box still has default + # options. Nested Box/BoxList objects already carry the correct config + # from their own unpickle; recreating them here would drop box_dots etc. + if self._box_config.get("__unpickling") and isinstance(value, (Box, box.BoxList)): + return super().__setitem__(item, value) # This is the magic sauce that makes sub dictionaries into new box objects if isinstance(value, dict): # We always re-create even if it was already a Box object to pass down configurations correctly diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..5efada0 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -693,6 +693,37 @@ def test_pickle_default_box(self): loaded = pickle.loads(pickle.dumps(bb)) assert bb == loaded + def test_pickle_preserves_nested_box_dots(self): + """Nested boxes must keep box_dots after pickle (#260).""" + if platform.python_implementation() == "PyPy": + pytest.skip("Pickling does not work correctly on PyPy") + original = Box( + { + "l1": { + "time_range_selected_utc": { + "left": "2023-03-01 10:00:00", + "right": "2023-06-01 10:00:00", + } + } + }, + box_dots=True, + conversion_box=False, + ) + assert original["l1.time_range_selected_utc.right"] == "2023-06-01 10:00:00" + + loaded = pickle.loads(pickle.dumps(original)) + assert loaded._box_config["box_dots"] is True + assert loaded.l1._box_config["box_dots"] is True + assert loaded.l1.time_range_selected_utc._box_config["box_dots"] is True + assert loaded["l1.time_range_selected_utc.right"] == "2023-06-01 10:00:00" + assert loaded["l1.time_range_selected_utc.left"] == "2023-03-01 10:00:00" + + # Normal construction still reapplies parent options onto a nested Box + inner = Box({"b": 1}, box_dots=False) + outer = Box({"a": inner}, box_dots=True) + assert outer.a._box_config["box_dots"] is True + assert outer["a.b"] == 1 + def test_conversion_dup_only(self): with pytest.raises(BoxError): Box(movie_data, conversion_box=False, box_duplicates="error") From 6f411e0bdc887ce6482d9cb22ec93510b5a77069 Mon Sep 17 00:00:00 2001 From: "Chris (ChrisJr404)" <11917633+ChrisJr404@users.noreply.github.com> Date: Tue, 18 Aug 2026 23:19:37 -0400 Subject: [PATCH 12/61] Add a merge option for box_merge_lists merge_update can already combine lists with extend and unique, but there was no way to merge lists of dictionaries the way nested dicts merge. Add a "merge" option that walks both lists by index, recursing into dicts at the same position so their keys combine and appending any extra incoming items. Closes #263. --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ box/box.py | 32 ++++++++++++++++++++++++++++++++ test/test_box.py | 21 +++++++++++++++++++++ 4 files changed, 59 insertions(+) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..00d56c0 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -98,3 +98,4 @@ Suggestions and bug reporting: - d00m514y3r - Sébastien Weber (seb5g) - Ward Loos (wrdls) +- Chris (ChrisJr404) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..49c6ba8 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Adding #263 ``"merge"`` option for ``box_merge_lists`` to merge lists of dictionaries element by element + Version 7.4.1 ------------- diff --git a/box/box.py b/box/box.py index 8252643..ab42c71 100644 --- a/box/box.py +++ b/box/box.py @@ -834,6 +834,27 @@ def update(self, *args, **kwargs): self.__convert_and_store(k, kwargs[k]) def merge_update(self, *args, **kwargs): + """ + Recursively update the Box, merging nested dictionaries instead of + overwriting them like the built-in ``dict.update``. + + The ``box_merge_lists`` keyword controls how lists sharing a key are + combined: + + * ``None`` (default) - the incoming list replaces the existing one + * ``"extend"`` - the incoming items are appended to the existing list + * ``"unique"`` - only incoming items not already present are appended + * ``"merge"`` - lists are merged element by element, recursing into + dictionaries that share the same index so their keys are combined + + .. code-block:: python + + box_one = Box({"data": [{"a": 1}, {"b": 2}]}) + box_one.merge_update({"data": [{"c": 3}]}, box_merge_lists="merge") + # Box({'data': [{'a': 1, 'c': 3}, {'b': 2}]}) + + :param box_merge_lists: strategy used to merge lists, see above + """ merge_type = None if "box_merge_lists" in kwargs: merge_type = kwargs.pop("box_merge_lists") @@ -866,6 +887,17 @@ def convert_and_set(k, v): if item not in self[k]: self[k].append(item) return + if merge_type == "merge" and k in self and isinstance(self[k], list): + for index, item in enumerate(v): + if index < len(self[k]) and isinstance(self[k][index], dict) and isinstance(item, dict): + self[k][index].merge_update( + item, box_merge_lists=merge_type, _force_unfrozen=force_unfrozen + ) + elif index < len(self[k]): + self[k][index] = item + else: + self[k].append(item) + return self.__setitem__(k, v) if (len(args) + int(bool(kwargs))) > 1: diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..63f8e17 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -1328,6 +1328,27 @@ def test_merge_list_options(self): {"app": {"S3": {"S3Service": [{"bucket": "bucket001"}, {"expirationDate": "2099-10-25"}]}}} ), box1 + def test_merge_list_merge_option(self): + # Lists of dictionaries are merged element by element + box1 = Box({"data": [{"foo": 1, "foobar": 20}, {"bar": 2}]}) + box1.merge_update({"data": [{"foo": 1, "baz": 10}]}, box_merge_lists="merge") + assert box1 == Box({"data": [{"foo": 1, "foobar": 20, "baz": 10}, {"bar": 2}]}), box1 + + # Extra incoming elements are appended, nested dictionaries recurse + box2 = Box({"app": {"servers": [{"name": "web", "tags": {"a": 1}}]}}) + box2.merge_update({"app": {"servers": [{"tags": {"b": 2}}, {"name": "db"}]}}, box_merge_lists="merge") + assert box2 == Box({"app": {"servers": [{"name": "web", "tags": {"a": 1, "b": 2}}, {"name": "db"}]}}), box2 + + # Non-dict elements at a shared index are overwritten + box3 = Box({"nums": [1, 2, 3]}) + box3.merge_update({"nums": [9, 8]}, box_merge_lists="merge") + assert box3.nums == [9, 8, 3] + + # Falls back to assignment when the existing value is not a list + box4 = Box({"data": 5}) + box4.merge_update({"data": [{"a": 1}]}, box_merge_lists="merge") + assert box4 == Box({"data": [{"a": 1}]}), box4 + def test_box_from_empty_yaml(self): out = Box.from_yaml("---") assert out == Box() From 46006d5a0e8cc8a1b0f31baafe8a184723a78ff8 Mon Sep 17 00:00:00 2001 From: Guo Jiarui <799423879@qq.com> Date: Mon, 7 Sep 2026 14:18:30 +0800 Subject: [PATCH 13/61] Resolve CamelCase prefixes in dotted Box lookups --- box/box.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/box/box.py b/box/box.py index 8252643..2652611 100644 --- a/box/box.py +++ b/box/box.py @@ -620,6 +620,8 @@ def __getitem__(self, item, _ignore_default=False): if self._box_config["default_box"] and not _ignore_default: return self.__get_default(item) raise BoxKeyError(str(item)) from _exception_cause(err) + if first_item not in self.keys() and self._box_config["camel_killer_box"]: + first_item = _camel_killer(first_item) if first_item in self.keys(): if hasattr(self[first_item], "__getitem__"): return self[first_item][children] From 3ae657ad30a3d4d93157746c1a89d9cb1ebec872 Mon Sep 17 00:00:00 2001 From: Guo Jiarui <799423879@qq.com> Date: Mon, 7 Sep 2026 14:19:05 +0800 Subject: [PATCH 14/61] Test CamelCase paths, defaults and exact-key precedence --- test/test_box.py | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..4d05376 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -539,6 +539,47 @@ def test_default_and_camel_killer_box(self): assert isinstance(killer_default_box.does_not_exist, Box) assert isinstance(killer_default_box["does_not_exist"], Box) + @pytest.mark.parametrize("default_box", [False, True]) + @pytest.mark.parametrize("conversion_box", [False, True]) + def test_camel_killer_box_dotted_lookup(self, default_box, conversion_box): + bx = Box( + {"someKey": [{"innerKey": "value"}], "otherKey": {"innerKey": "value"}}, + camel_killer_box=True, + box_dots=True, + default_box=default_box, + conversion_box=conversion_box, + ) + + for key in ( + "some_key[0].inner_key", + "some_key[0].innerKey", + "someKey[0].innerKey", + "SomeKey[0].InnerKey", + "other_key.inner_key", + "otherKey.innerKey", + "OtherKey.InnerKey", + ): + assert bx[key] == "value" + assert bx.to_dict() == {"some_key": [{"inner_key": "value"}], "other_key": {"inner_key": "value"}} + + @pytest.mark.parametrize("camel_killer_box, box_dots", [(False, True), (True, False)]) + def test_camel_killer_box_dotted_lookup_disabled(self, camel_killer_box, box_dots): + bx = Box({"some_key": {"inner_key": "value"}}, camel_killer_box=camel_killer_box, box_dots=box_dots) + + with pytest.raises(BoxKeyError): + bx["someKey.innerKey"] + assert bx.to_dict() == {"some_key": {"inner_key": "value"}} + + def test_camel_killer_box_dotted_lookup_exact_key(self): + bx = Box({"someKey": {"innerKey": "converted"}}, camel_killer_box=True, box_dots=True) + bx.update({"someKey": {"innerKey": "exact"}}) + + assert bx["someKey.innerKey"] == "exact" + assert bx["some_key.innerKey"] == "converted" + + bx.update({"someKey.innerKey": "literal"}) + assert bx["someKey.innerKey"] == "literal" + def test_box_modify_tuples(self): bx = Box(extended_test_dict, modify_tuples_box=True) assert bx.tuples_galore[0].item == 3 From 719eb0da8ff9b00755df0baa9bdd26d5e2d36177 Mon Sep 17 00:00:00 2001 From: Guo Jiarui <799423879@qq.com> Date: Mon, 7 Sep 2026 14:19:34 +0800 Subject: [PATCH 15/61] Document CamelCase path lookup fix and contributor --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..a98c02b 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,7 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- Guo Jiarui (Jerry-val) Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..5ac7fbc 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Fixing #300 CamelCase keys in dotted and indexed lookups with camel_killer_box (thanks to Guo Jiarui) + Version 7.4.1 ------------- From d5ffb611524b05571372a68329dd39d4e1240e84 Mon Sep 17 00:00:00 2001 From: Gyanu Mayank Date: Tue, 8 Sep 2026 11:39:46 +0530 Subject: [PATCH 16/61] Flush pending default_box parents on assignment. default_box_create_on_get=False still needs b.foo.bar = 1 to persist. Lookups stay ephemeral. Writes attach the pending chain. --- box/box.py | 18 ++++++++++++++++++ test/test_box.py | 9 +++++++++ 2 files changed, 27 insertions(+) diff --git a/box/box.py b/box/box.py index 8252643..e294f5e 100644 --- a/box/box.py +++ b/box/box.py @@ -549,6 +549,10 @@ def __get_default(self, item, attr=False): self[first_item].__setitem__(children, value) else: super().__setitem__(item, value) + elif isinstance(value, Box): + # Lookups stay ephemeral, but a later assignment on this child + # should create the missing parent keys. + value._box_config["__pending_parent"] = (self, item) return value def __box_config(self, extra_namespace: Any = NO_NAMESPACE) -> dict: @@ -660,7 +664,18 @@ def __getattr__(self, item): raise BoxKeyError(str(err)) from _exception_cause(err) return value + def _flush_pending_parent(self): + pending = self._box_config.pop("__pending_parent", None) + if pending is None: + return + parent, key = pending + parent_flush = getattr(parent, "_flush_pending_parent", None) + if parent_flush is not None: + parent_flush() + dict.__setitem__(parent, key, self) + def __setitem__(self, key, value): + self._flush_pending_parent() if key != "_box_config" and self._box_config["frozen_box"] and self._box_config["__created"]: raise BoxError("Box is frozen") if self.__process_dotted_key(key): @@ -687,6 +702,8 @@ def __setitem__(self, key, value): self.__convert_and_store(key, value) def __setattr__(self, key, value): + if key != "_box_config": + self._flush_pending_parent() if key == "_box_config": return object.__setattr__(self, key, value) if self._box_config["frozen_box"] and self._box_config["__created"]: @@ -705,6 +722,7 @@ def __setattr__(self, key, value): self.__setitem__(key, value) def __delitem__(self, key): + self._flush_pending_parent() if self._box_config["frozen_box"]: raise BoxError("Box is frozen") if key not in self.keys() and self.__process_dotted_key(key): diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..e6513fc 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -1427,6 +1427,15 @@ def test_box_default_not_create_on_get(self): assert box2 == Box() + box2.foo.bar = 1 + assert box2.foo.bar == 1 + assert box2 == Box({"foo": {"bar": 1}}) + + box3 = Box(default_box=True, default_box_create_on_get=False) + box3.a.b.c = "nested" + assert box3.a.b.c == "nested" + assert box3["a"]["b"]["c"] == "nested" + def test_box_property_support(self): class BoxWithProperty(Box): def __init__(self, *args, **kwargs): From 5bdd15ad951539e96626b222a4fe312d0457f91f Mon Sep 17 00:00:00 2001 From: Vitaliy <160263432+vitalivo@users.noreply.github.com> Date: Sat, 12 Sep 2026 17:39:03 +0300 Subject: [PATCH 17/61] Protect frozen BoxLists against remaining in-place mutations --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ box/box_list.py | 12 +++++++++++- test/test_box_list.py | 25 +++++++++++++++++++++++++ 4 files changed, 42 insertions(+), 1 deletion(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..d8044c4 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -98,3 +98,4 @@ Suggestions and bug reporting: - d00m514y3r - Sébastien Weber (seb5g) - Ward Loos (wrdls) +- Vitaliy Voloshin (vitalivo) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..3ac66a8 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Prevent frozen BoxList mutation through clear, in-place addition, and in-place multiplication. + Version 7.4.1 ------------- diff --git a/box/box_list.py b/box/box_list.py index 72609ff..2988d90 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -62,7 +62,7 @@ def __init__(self, iterable: Iterable | None = None, box_class: type[box.Box] = def frozen(*args, **kwargs): raise BoxError("BoxList is frozen") - for method in ["append", "extend", "insert", "pop", "remove", "reverse", "sort"]: + for method in ["append", "clear", "extend", "insert", "pop", "remove", "reverse", "sort"]: self.__setattr__(method, frozen) def __getitem__(self, item): @@ -113,6 +113,16 @@ def __setitem__(self, key, value): return super().__getitem__(pos).__setitem__(children, value) super().__setitem__(key, value) + def __iadd__(self, value): + if self.box_options.get("frozen_box"): + raise BoxError("BoxList is frozen") + return super().__iadd__(value) + + def __imul__(self, value): + if self.box_options.get("frozen_box"): + raise BoxError("BoxList is frozen") + return super().__imul__(value) + def _is_intact_type(self, obj): if self.box_options.get("box_intact_types") and isinstance(obj, self.box_options["box_intact_types"]): return True diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e0..7f6a1b5 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -3,6 +3,7 @@ # Test files gathered from json.org and yaml.org import json +import operator import os import shutil import sys @@ -274,3 +275,27 @@ def test_circular_references(self): circular_list.append(circular_list) circular_box = BoxList(circular_list) assert circular_box[0] == circular_box + + +@pytest.mark.parametrize( + "mutate, expected", + [ + (lambda value: value.clear(), []), + (lambda value: operator.iadd(value, [3]), [1, 2, 3]), + (lambda value: operator.imul(value, 2), [1, 2, 1, 2]), + (lambda value: operator.imul(value, 0), []), + ], +) +def test_frozen_list_inplace_mutations(mutate, expected): + frozen = BoxList([1, 2], frozen_box=True) + original_hash = hash(frozen) + with pytest.raises(BoxError, match="BoxList is frozen"): + mutate(frozen) + assert frozen == [1, 2] + assert hash(frozen) == original_hash + + mutable = BoxList([1, 2]) + alias = mutable + mutate(mutable) + assert mutable is alias + assert mutable == expected From b8604f20372f47eaac8793d5d71aba2b2ac752f0 Mon Sep 17 00:00:00 2001 From: Alex <100605452+Likio3000@users.noreply.github.com> Date: Wed, 23 Sep 2026 02:22:28 +1000 Subject: [PATCH 18/61] docs: correct optional dependency installation examples --- AUTHORS.rst | 5 +++++ CHANGES.rst | 5 +++++ README.rst | 9 +++++---- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..16ae30e 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -39,6 +39,11 @@ Code contributions: - m-janicki +Documentation contributions: + +- Likio3000 + + Suggestions and bug reporting: - JiuLi Gao (gaojiuli) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..da2fecf 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Correct installation examples for optional dependencies and shell quoting. + Version 7.4.1 ------------- diff --git a/README.rst b/README.rst index 9fc9f31..233dfc7 100644 --- a/README.rst +++ b/README.rst @@ -44,7 +44,7 @@ Install from command line .. code:: bash python -m pip install --upgrade pip - pip install python-box[all]~=7.0 --upgrade + pip install "python-box[all]~=7.0" --upgrade Install with selected dependencies ---------------------------------- @@ -54,9 +54,10 @@ for example, `[all]` is shorthand for: .. code:: bash - pip install python-box[ruamel.yaml,tomli_w,msgpack]~=7.0 --upgrade + pip install "python-box[ruamel.yaml,toml,msgpack]~=7.0" --upgrade -But you can also sub out `ruamel.yaml` for `PyYAML`. +But you can also sub out `ruamel.yaml` for `PyYAML`. To use ``tomli-w`` for TOML output, +select the ``tomli`` extra instead of ``toml``. Check out `more details `_ on installation details. @@ -81,7 +82,7 @@ You will then need `Cython` and `wheel` installed and then install (or re-instal .. code:: bash pip install Cython wheel - pip install python-box[all]~=7.0 --upgrade --force + pip install "python-box[all]~=7.0" --upgrade --force If you have any issues please open a github issue with the error you are experiencing! From d91be7dc8f99d8db048bde5c6eb914432294e6cb Mon Sep 17 00:00:00 2001 From: x0Lazarus <113273587+x0Lazarus@users.noreply.github.com> Date: Sat, 26 Sep 2026 13:36:42 -0700 Subject: [PATCH 19/61] Convert replacement values in BoxList assignments --- AUTHORS.rst | 1 + CHANGES.rst | 5 ++ box/box_list.py | 12 ++++- test/test_box_list.py | 111 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 127 insertions(+), 2 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..9ffe1e4 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -98,3 +98,4 @@ Suggestions and bug reporting: - d00m514y3r - Sébastien Weber (seb5g) - Ward Loos (wrdls) +- x0Lazarus diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..71a1fb1 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Convert dictionaries and lists assigned to BoxList items and slices, preserving the list's options (thanks to x0Lazarus). + Version 7.4.1 ------------- diff --git a/box/box_list.py b/box/box_list.py index 72609ff..7d3a424 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -103,7 +103,7 @@ def __setitem__(self, key, value): if pos >= len(self) and self.box_options.get("default_box"): self.extend([None] * (pos - len(self) + 1)) if len(list_pos.group()) == len(key): - return super().__setitem__(pos, value) + return super().__setitem__(pos, self._convert(value)) children = key[len(list_pos.group()) :].lstrip(".") if self.box_options.get("default_box"): if children[0] == "[": @@ -111,7 +111,15 @@ def __setitem__(self, key, value): else: super().__setitem__(pos, self.box_options.get("box_class")(**self.box_options)) return super().__getitem__(pos).__setitem__(children, value) - super().__setitem__(key, value) + if isinstance(key, slice): + + def converted_items(): + for item in value: + yield self._convert(item) + + # Let list validate the slice before consuming replacement values. + return super().__setitem__(key, converted_items()) + super().__setitem__(key, self._convert(value)) def _is_intact_type(self, obj): if self.box_options.get("box_intact_types") and isinstance(obj, self.box_options["box_intact_types"]): diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e0..4f9496c 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -74,6 +74,117 @@ def test_frozen_list(self): bl2[1] = 4 assert bl2[1] == 4 + @pytest.mark.parametrize("index", [0, -1, "[0]", "[1]"]) + @pytest.mark.parametrize("container", ["mapping", "sequence"]) + def test_assigned_containers_are_converted(self, index, container): + class ChildBox(Box): + pass + + data = BoxList([None], box_dots=True, default_box=True, camel_killer_box=True, box_class=ChildBox) + value = {"SomeKey": 7} if container == "mapping" else [{"SomeKey": 7}] + data[index] = value + assigned = data[1 if index == "[1]" else 0] + if container == "sequence": + assert isinstance(assigned, BoxList) + assigned = assigned[0] + assert isinstance(assigned, ChildBox) + assert assigned.some_key == 7 + assert assigned._box_config["box_dots"] is True + + @pytest.mark.parametrize( + "selection, count", [(slice(1, 2), 2), (slice(None, None, 2), 2), (slice(None, None, -1), 3), (slice(2, 2), 2)] + ) + def test_slice_assignment_converts_containers(self, selection, count): + data = BoxList([0, 1, 2], camel_killer_box=True) + values = [{"SomeKey": number} if number % 2 == 0 else [{"SomeKey": number}] for number in range(count)] + expected = [0, 1, 2] + expected[selection] = [ + {"some_key": number} if number % 2 == 0 else [{"some_key": number}] for number in range(count) + ] + data[selection] = (value for value in values) + assert data.to_list() == expected + for value in data: + if isinstance(value, dict): + assert isinstance(value, Box) + assert value.some_key in range(count) + elif isinstance(value, list): + assert isinstance(value, BoxList) + assert isinstance(value[0], Box) + assert value[0].some_key in range(count) + + @pytest.mark.parametrize("index", [0, "[0]", slice(None)]) + def test_assignment_respects_intact_types(self, index): + value = {"SomeKey": 7} + data = BoxList([None], box_dots=True, box_intact_types=(dict,)) + data[index] = [value] if isinstance(index, slice) else value + assert data[0] is value + + @pytest.mark.parametrize("index", [0, "[0]", slice(None)]) + def test_frozen_assignment_keeps_contents(self, index): + data = BoxList([1], frozen_box=True, box_dots=True) + with pytest.raises(BoxError): + data[index] = [{"key": 2}] if isinstance(index, slice) else {"key": 2} + assert data == [1] + + def test_invalid_slice_assignment_keeps_contents(self): + data = BoxList([0, 1, 2]) + with pytest.raises(ValueError): + data[::2] = [{"key": 1}] + assert data == [0, 1, 2] + with pytest.raises(TypeError): + data[:] = 3 + assert data == [0, 1, 2] + + @pytest.mark.parametrize("replacement_kind", ["generator", "iterable", "noniterable"]) + def test_zero_step_does_not_consume_replacements(self, replacement_kind): + consumed = [] + + def replacements(): + consumed.append(True) + yield {"key": 1} + + class Unreadable: + def __iter__(self): + raise RuntimeError("replacement must not be read") + + value = {"generator": replacements(), "iterable": Unreadable(), "noniterable": 3}[replacement_kind] + data = BoxList([0, 1, 2]) + with pytest.raises(ValueError, match="slice step cannot be zero"): + data[::0] = value + assert consumed == [] + assert data == [0, 1, 2] + + @pytest.mark.parametrize("bounds", [(0, 4, 1), (3, -5, -2)]) + def test_slice_bounds_are_evaluated_once_before_replacements(self, bounds): + def assign(list_type): + events = [] + + class Index: + def __init__(self, name, value): + self.name = name + self.value = value + + def __index__(self): + events.append(self.name) + return self.value + + class Replacements: + def __iter__(self): + events.append("iter") + return iter([8, 9]) + + selection = slice(*(Index(name, value) for name, value in zip(("start", "stop", "step"), bounds))) + data = list_type([0, 1, 2, 3]) + data[selection] = Replacements() + return data, events + + expected, expected_events = assign(list) + actual, actual_events = assign(BoxList) + assert actual == expected + assert actual_events == expected_events + assert sorted(actual_events[:3]) == ["start", "step", "stop"] + assert actual_events[3:] == ["iter"] + def test_box_list_to_json(self): bl = BoxList([{"item": 1, "CamelBad": 2}]) assert json.loads(bl.to_json())[0]["item"] == 1 From e4214f8f3c2b50eea033de9805ef77f484355dae Mon Sep 17 00:00:00 2001 From: x0Lazarus <113273587+x0Lazarus@users.noreply.github.com> Date: Sat, 26 Sep 2026 16:45:02 -0700 Subject: [PATCH 20/61] Fix BoxList extending itself --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ box/box_list.py | 2 ++ test/test_box_list.py | 36 ++++++++++++++++++++++++++++++++++++ 4 files changed, 44 insertions(+) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..9ffe1e4 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -98,3 +98,4 @@ Suggestions and bug reporting: - d00m514y3r - Sébastien Weber (seb5g) - Ward Loos (wrdls) +- x0Lazarus diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..e83b5fd 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Allow BoxList.extend to append its own contents once, like list.extend (thanks to x0Lazarus). + Version 7.4.1 ------------- diff --git a/box/box_list.py b/box/box_list.py index 72609ff..4b95008 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -137,6 +137,8 @@ def append(self, p_object): super().append(self._convert(p_object)) def extend(self, iterable): + if iterable is self: + iterable = list(self) for item in iterable: self.append(item) diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e0..83f8b69 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -50,6 +50,42 @@ def test_box_list(self): assert isinstance(new_list[1], BoxList) assert not isinstance(new_list.to_list(), BoxList) + @pytest.mark.parametrize("values", [[], [1], [1, 2], [{"SomeKey": 3}, [4]]]) + def test_extend_self(self, values, monkeypatch): + data = BoxList(values, camel_killer_box=True) + expected = data.to_list() * 2 + append = data.append + remaining = len(data) + + def bounded_append(item): + nonlocal remaining + assert remaining > 0, "extend revisited an appended element" + remaining -= 1 + append(item) + + # Bound the regression test even if extend iterates its growing destination. + monkeypatch.setattr(data, "append", bounded_append) + assert data.extend(data) is None + assert remaining == 0 + assert data.to_list() == expected + if values and isinstance(values[0], dict): + assert isinstance(data[2], Box) + assert data[2].some_key == 3 + assert isinstance(data[3], BoxList) + + def test_extend_generator_preserves_partial_progress(self): + data = BoxList([0]) + + def items(): + yield {"value": 1} + raise ValueError("unfinished input") + + with pytest.raises(ValueError, match="unfinished input"): + data.extend(items()) + assert data[0] == 0 + assert isinstance(data[1], Box) + assert data[1].value == 1 + def test_frozen_list(self): bl = BoxList([5, 4, 3], frozen_box=True) with pytest.raises(BoxError): From 67e340e5b5a792c6a098c2c52cd4feb2353b2346 Mon Sep 17 00:00:00 2001 From: machines-6657 Date: Sat, 3 Oct 2026 17:13:15 +0800 Subject: [PATCH 21/61] Fix Box.popitem LIFO order --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ box/box.py | 2 +- test/test_box.py | 3 ++- 4 files changed, 9 insertions(+), 2 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..96bfe3b 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,7 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- machines-6657 (machines-6657) Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..3d01514 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Fix `Box.popitem()` to remove the most recently inserted item, matching `dict.popitem()`. + Version 7.4.1 ------------- diff --git a/box/box.py b/box/box.py index 8252643..1acb685 100644 --- a/box/box.py +++ b/box/box.py @@ -782,7 +782,7 @@ def popitem(self): if self._box_config["frozen_box"]: raise BoxError("Box is frozen") try: - key = next(self.__iter__()) + key = next(self.__reversed__()) except StopIteration: raise BoxKeyError("Empty box") from None return key, self.pop(key) diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..e5ccab3 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -882,7 +882,8 @@ def test_pop(self): assert bx.pop("c", True) is not True def test_pop_items(self): - bx = Box(a=4) + bx = Box(a=4, b=5) + assert bx.popitem() == ("b", 5) assert bx.popitem() == ("a", 4) with pytest.raises(BoxKeyError): assert bx.popitem() From 1e41733b4245cd015e02e6af10873a7bc992308e Mon Sep 17 00:00:00 2001 From: Arindam Sikder <88596876+arindamsikder@users.noreply.github.com> Date: Mon, 5 Oct 2026 08:21:37 +0530 Subject: [PATCH 22/61] fix: report malformed BoxList bracket indices Guard unmatched index expressions in dotted reads, writes and deletes. Add regressions for nested paths, default/frozen modes and YAML loading. Independent review: passed (security and logic). AI-assisted contribution prepared with Hermes DEV. --- AUTHORS.rst | 1 + CHANGES.rst | 5 ++++ box/box_list.py | 6 +++++ test/test_box.py | 9 +++++++ test/test_box_list.py | 55 +++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 76 insertions(+) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..6b60bcc 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,7 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- Arindam Sikder (arindamsikder) Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..2371794 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Raise a clear error for bracket paths without a numeric list index instead of AttributeError (#265). + Version 7.4.1 ------------- diff --git a/box/box_list.py b/box/box_list.py index 72609ff..2876d95 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -68,6 +68,8 @@ def frozen(*args, **kwargs): def __getitem__(self, item): if self.box_options.get("box_dots") and isinstance(item, str) and item.startswith("["): list_pos = _list_pos_re.search(item) + if list_pos is None: + raise BoxTypeError(f"Invalid list index: {item!r}") value = super().__getitem__(int(list_pos.groups()[0])) if len(list_pos.group()) == len(item): return value @@ -87,6 +89,8 @@ def __delitem__(self, key): raise BoxError("BoxList is frozen") if self.box_options.get("box_dots") and isinstance(key, str) and key.startswith("["): list_pos = _list_pos_re.search(key) + if list_pos is None: + raise BoxTypeError(f"Invalid list index: {key!r}") pos = int(list_pos.groups()[0]) if len(list_pos.group()) == len(key): return super().__delitem__(pos) @@ -99,6 +103,8 @@ def __setitem__(self, key, value): raise BoxError("BoxList is frozen") if self.box_options.get("box_dots") and isinstance(key, str) and key.startswith("["): list_pos = _list_pos_re.search(key) + if list_pos is None: + raise BoxTypeError(f"Invalid list index: {key!r}") pos = int(list_pos.groups()[0]) if pos >= len(self) and self.box_options.get("default_box"): self.extend([None] * (pos - len(self) + 1)) diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..2ec44ae 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -349,6 +349,15 @@ def test_from_json_file(self): assert isinstance(bx, Box) assert bx.widget.window.height == 500 + def test_from_yaml_invalid_bracket_key(self): + key = r"^[^_^\d][\w]*$" + yaml_string = f"'{key}': {{}}" + with pytest.raises(BoxError) as error: + Box.from_yaml(yaml_string, default_box=True, box_dots=True) + assert "Invalid list index" in str(error.value) + assert repr(key[1:]) in str(error.value) + assert Box.from_yaml(yaml_string, default_box=True, box_dots=False).to_dict() == {key: {}} + def test_from_yaml_file(self): bx = Box.from_yaml(filename=data_yaml_file) assert isinstance(bx, Box) diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e0..5010007 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -222,6 +222,61 @@ def test_box_list_dots(self): for key in keys: db[key] + @pytest.mark.parametrize("key", ["[x]", "[]", "[", "[1x]"]) + @pytest.mark.parametrize("default_box", [False, True]) + def test_box_list_dots_invalid_get(self, key, default_box): + data = BoxList([{"value": 1}], box_dots=True, default_box=default_box) + with pytest.raises(BoxError) as error: + data[key] + assert "Invalid list index" in str(error.value) + assert repr(key) in str(error.value) + assert data.to_list() == [{"value": 1}] + + @pytest.mark.parametrize("key", ["[x]", "[]", "[", "[1x]"]) + @pytest.mark.parametrize("default_box", [False, True]) + def test_box_list_dots_invalid_set(self, key, default_box): + data = BoxList([{"value": 1}], box_dots=True, default_box=default_box) + with pytest.raises(BoxError) as error: + data[key] = 2 + assert "Invalid list index" in str(error.value) + assert repr(key) in str(error.value) + assert data.to_list() == [{"value": 1}] + + @pytest.mark.parametrize("key", ["[x]", "[]", "[", "[1x]"]) + @pytest.mark.parametrize("default_box", [False, True]) + def test_box_list_dots_invalid_delete(self, key, default_box): + data = BoxList([{"value": 1}], box_dots=True, default_box=default_box) + with pytest.raises(BoxError) as error: + del data[key] + assert "Invalid list index" in str(error.value) + assert repr(key) in str(error.value) + assert data.to_list() == [{"value": 1}] + + @pytest.mark.parametrize("method, args", [("__getitem__", ()), ("__setitem__", (2,)), ("__delitem__", ())]) + def test_box_list_dots_invalid_nested_index(self, method, args): + data = BoxList([[1]], box_dots=True) + with pytest.raises(BoxError) as error: + getattr(data, method)("[0][x]", *args) + assert "Invalid list index: '[x]'" in str(error.value) + assert data.to_list() == [[1]] + + def test_box_list_dots_frozen_invalid_index(self): + data = BoxList([1], box_dots=True, frozen_box=True) + with pytest.raises(BoxError, match="Invalid list index"): + data["[x]"] + with pytest.raises(BoxError, match="BoxList is frozen"): + data["[x]"] = 2 + with pytest.raises(BoxError, match="BoxList is frozen"): + del data["[x]"] + assert data.to_list() == [1] + + @pytest.mark.parametrize("method, args", [("__getitem__", ()), ("__setitem__", (2,)), ("__delitem__", ())]) + def test_box_list_invalid_index_without_dots(self, method, args): + data = BoxList([1], box_dots=False) + with pytest.raises(TypeError, match="list indices must be integers or slices"): + getattr(data, method)("[x]", *args) + assert data.to_list() == [1] + def test_box_list_default_dots(self): box_1 = Box(default_box=True, box_dots=True) box_1["a[0]"] = 42 From ec3ade97d82b6b28ac5d738cd4c441574e8fd8ab Mon Sep 17 00:00:00 2001 From: fhgffy <102001626+fhgffy@users.noreply.github.com> Date: Sat, 10 Oct 2026 00:33:14 +0800 Subject: [PATCH 23/61] Construct BoxList without testing the input truth value --- AUTHORS.rst | 2 ++ CHANGES.rst | 5 +++++ box/box_list.py | 3 ++- test/test_box_list.py | 16 ++++++++++++++++ 4 files changed, 25 insertions(+), 1 deletion(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..3c6321f 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,6 +5,8 @@ reporting, all input is greatly appreciated! Code contributions: +- fhgffy + - Alexandre Decan (AlexandreDecan) - dhilipsiva (dhilipsiva) - MAA (FooBarQuaxx) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..4de668e 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Fix BoxList construction from iterable inputs with false or ambiguous truth values. + Version 7.4.1 ------------- diff --git a/box/box_list.py b/box/box_list.py index 72609ff..91b42ae 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -53,7 +53,8 @@ def __init__(self, iterable: Iterable | None = None, box_class: type[box.Box] = self.box_options = box_options self.box_options["box_class"] = box_class self.box_org_ref = iterable - if iterable: + # 2026-10-10: Iteration does not require a truth value. + if iterable is not None: for x in iterable: self.append(x) self.box_org_ref = None diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e0..afb7fc8 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -50,6 +50,22 @@ def test_box_list(self): assert isinstance(new_list[1], BoxList) assert not isinstance(new_list.to_list(), BoxList) + @pytest.mark.parametrize("falsey", [False, True]) + def test_box_list_does_not_require_iterable_truth_value(self, falsey): + # 2026-10-10: Iterable inputs can be falsey or have no boolean value. + class Rows: + def __iter__(self): + return iter([{"value": 1}]) + + def __bool__(self): + if falsey: + return False + raise ValueError("ambiguous truth value") + + result = BoxList(Rows()) + assert len(result) == 1 + assert result[0].value == 1 + def test_frozen_list(self): bl = BoxList([5, 4, 3], frozen_box=True) with pytest.raises(BoxError): From 4dcd563a8745fd95e1e217cc1cb33beca8f176c5 Mon Sep 17 00:00:00 2001 From: shguild Date: Sat, 10 Oct 2026 09:56:56 +0800 Subject: [PATCH 24/61] docs: record JSON Lines string fix --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..bed48fe 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,7 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- shguild Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..da412d7 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Honor ``multiline=True`` for BoxList JSON string input and output, matching file behavior. + Version 7.4.1 ------------- From 2501db0f5a3b8d25838da59c137cd3eb78465201 Mon Sep 17 00:00:00 2001 From: shguild Date: Sat, 10 Oct 2026 09:58:26 +0800 Subject: [PATCH 25/61] fix: honor multiline JSON for strings --- box/box_list.py | 14 +++++++++----- box/converters.py | 11 +++++++++-- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/box/box_list.py b/box/box_list.py index 72609ff..b22ce04 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -210,14 +210,18 @@ def to_json( :param filename: If provided will save to file :param encoding: File encoding :param errors: How to handle encoding errors - :param multiline: Put each item in list onto it's own line + :param multiline: Put each item in list onto its own line, in a string or file :param json_kwargs: additional arguments to pass to json.dump(s) :return: string of JSON or return of `json.dump` """ - if filename and multiline: + if multiline: lines = [_to_json(item, filename=None, encoding=encoding, errors=errors, **json_kwargs) for item in self] - with open(filename, "w", encoding=encoding, errors=errors) as f: - f.write("\n".join(lines)) + text = "\n".join(lines) + if filename: + with open(filename, "w", encoding=encoding, errors=errors) as f: + f.write(text) + else: + return text else: return _to_json(self.to_list(), filename=filename, encoding=encoding, errors=errors, **json_kwargs) @@ -239,7 +243,7 @@ def from_json( :param filename: filename to open and pass to `json.load` :param encoding: File encoding :param errors: How to handle encoding errors - :param multiline: One object per line + :param multiline: One object per line, in a string or file :param kwargs: parameters to pass to `Box()` or `json.loads` :return: BoxList object from json data """ diff --git a/box/converters.py b/box/converters.py index bb91ba6..055caa1 100644 --- a/box/converters.py +++ b/box/converters.py @@ -182,8 +182,15 @@ def _from_json( ] else: data = json.load(f, **kwargs) - elif json_string: - data = json.loads(json_string, **kwargs) + elif json_string or (multiline and json_string is not None): + if multiline: + data = [ + json.loads(line.strip(), **kwargs) + for line in StringIO(json_string, newline=None) + if line.strip() and not line.strip().startswith("#") + ] + else: + data = json.loads(json_string, **kwargs) else: raise BoxError("from_json requires a string or filename") return data From f59cbc0ea178856c6d483a9b63b75408390c23a8 Mon Sep 17 00:00:00 2001 From: shguild Date: Sat, 10 Oct 2026 09:59:01 +0800 Subject: [PATCH 26/61] test: cover JSON Lines string round trips --- test/test_json_lines_strings.py | 63 +++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 test/test_json_lines_strings.py diff --git a/test/test_json_lines_strings.py b/test/test_json_lines_strings.py new file mode 100644 index 0000000..40ef6f6 --- /dev/null +++ b/test/test_json_lines_strings.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import json + +import pytest + +from box import BoxList + + +@pytest.mark.parametrize("data", [[], [{"a": 1}], [{"a": 1}, {"b": 2}], [None, False, 3, "café\u2028text"]]) +def test_multiline_string_output_matches_file(tmp_path, data): + values = BoxList(data) + path = tmp_path / "values.jsonl" + values.to_json(filename=path, multiline=True) + + result = values.to_json(multiline=True) + + assert result == path.read_text(encoding="utf-8") + assert result == "\n".join(json.dumps(value, ensure_ascii=False) for value in data) + + +@pytest.mark.parametrize("newline", ["\n", "\r\n", "\r"]) +def test_multiline_string_input_matches_file(tmp_path, newline): + text = newline.join(["# comment", "", '{"FirstKey": 1}', " ", ' {"SecondKey": "café\u2028text"} ', "# end"]) + path = tmp_path / "values.jsonl" + path.write_bytes(text.encode("utf-8")) + + result = BoxList.from_json(text, multiline=True, camel_killer_box=True) + from_file = BoxList.from_json(filename=path, multiline=True, camel_killer_box=True) + + assert result == from_file + assert result[0].first_key == 1 + assert result[1].second_key == "café\u2028text" + + +@pytest.mark.parametrize("text", ["", "\n \r\n", "# comment\n # another\n"]) +def test_empty_multiline_string_input(text): + assert BoxList.from_json(text, multiline=True) == [] + + +def test_multiline_string_json_options(): + values = BoxList([{"b": 2, "a": 1}, {"c": 3}]) + text = values.to_json(multiline=True, sort_keys=True, separators=(",", ":")) + + assert text == '{"a":1,"b":2}\n{"c":3}' + assert BoxList.from_json(text, multiline=True, parse_int=str) == [{"a": "1", "b": "2"}, {"c": "3"}] + + +@pytest.mark.parametrize("text", ['{"a": 1}\nnot json', '{"a": 1}\n{"b":']) +def test_multiline_string_rejects_invalid_json(text): + with pytest.raises(json.JSONDecodeError): + BoxList.from_json(text, multiline=True) + + +def test_multiple_objects_require_multiline(): + with pytest.raises(json.JSONDecodeError): + BoxList.from_json('{"a": 1}\n{"b": 2}') + + +def test_default_json_array_behavior(): + values = BoxList([{"a": 1}, {"b": 2}]) + assert json.loads(values.to_json()) == values.to_list() + assert BoxList.from_json(values.to_json()) == values From 858b7c541ccecc8b5bc03236ffda794064e5a868 Mon Sep 17 00:00:00 2001 From: Huanyi Xie <74809554+xiehuanyi@users.noreply.github.com> Date: Sat, 10 Oct 2026 14:58:19 +0300 Subject: [PATCH 27/61] Honor explicit pop defaults without creating missing values --- AUTHORS.rst | 2 ++ CHANGES.rst | 5 +++++ box/box.py | 10 +++++++--- box/box_list.py | 7 +++++-- test/test_box.py | 39 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 58 insertions(+), 5 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..0e7873e 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -98,3 +98,5 @@ Suggestions and bug reporting: - d00m514y3r - Sébastien Weber (seb5g) - Ward Loos (wrdls) + +- Huanyi Xie (xiehuanyi) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..a1acab8 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Honor explicit ``pop`` defaults without creating missing default-box values. + Version 7.4.1 ------------- diff --git a/box/box.py b/box/box.py index 8252643..6481aa1 100644 --- a/box/box.py +++ b/box/box.py @@ -5,6 +5,7 @@ """ Improved dictionary access through dot notation with additional tools. """ + from __future__ import annotations import copy @@ -621,8 +622,11 @@ def __getitem__(self, item, _ignore_default=False): return self.__get_default(item) raise BoxKeyError(str(item)) from _exception_cause(err) if first_item in self.keys(): - if hasattr(self[first_item], "__getitem__"): - return self[first_item][children] + child = self[first_item] + if hasattr(child, "__getitem__"): + if _ignore_default and isinstance(child, (Box, box.BoxList)): + return child.__getitem__(children, _ignore_default=True) + return child[children] if self._box_config["camel_killer_box"] and isinstance(item, str): converted = _camel_killer(item) if converted in self.keys(): @@ -758,7 +762,7 @@ def pop(self, key, *args): if len(args) != 1: raise BoxError('pop() takes only one optional argument "default"') try: - item = self[key] + item = self.__getitem__(key, _ignore_default=True) except KeyError: return args[0] else: diff --git a/box/box_list.py b/box/box_list.py index 72609ff..97e4b06 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -65,13 +65,16 @@ def frozen(*args, **kwargs): for method in ["append", "extend", "insert", "pop", "remove", "reverse", "sort"]: self.__setattr__(method, frozen) - def __getitem__(self, item): + def __getitem__(self, item, _ignore_default=False): if self.box_options.get("box_dots") and isinstance(item, str) and item.startswith("["): list_pos = _list_pos_re.search(item) value = super().__getitem__(int(list_pos.groups()[0])) if len(list_pos.group()) == len(item): return value - return value.__getitem__(item[len(list_pos.group()) :].lstrip(".")) + children = item[len(list_pos.group()) :].lstrip(".") + if _ignore_default and isinstance(value, (box.Box, BoxList)): + return value.__getitem__(children, _ignore_default=True) + return value.__getitem__(children) if isinstance(item, tuple): result = self for idx in item: diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..d7bb822 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -1506,3 +1506,42 @@ def func(box_instance, key): my_box = DDBox(default_box_attr=func) assert my_box.a == {"bi": "{}", "key": "a"} + + +@pytest.mark.parametrize("create_on_get", [True, False]) +@pytest.mark.parametrize("default", [None, 0, [], {"fallback": True}]) +def test_pop_explicit_default_without_autovivification(create_on_get, default): + calls = [] + + def factory(): + calls.append(None) + return "generated" + + value = Box(default_box=True, default_box_attr=factory, default_box_create_on_get=create_on_get) + assert value.pop("missing", default) is default + assert value == {} + assert calls == [] + value.present = 1 + assert value.pop("present", default) == 1 + assert value == {} + + +def test_pop_explicit_default_dotted_path(): + value = Box({"nested": {}}, default_box=True, box_dots=True) + default = object() + assert value.pop("nested.missing", default) is default + assert value.to_dict() == {"nested": {}} + + +def test_pop_explicit_default_camel_case_key(): + value = Box({"actualKey": 1}, default_box=True, camel_killer_box=True) + assert value.pop("actualKey", None) == 1 + assert value == {} + + +@pytest.mark.parametrize("path", ["items[0].missing", "items[1][0].missing"]) +def test_pop_explicit_default_dotted_list_path(path): + value = Box({"items": [{}, [{}]]}, default_box=True, box_dots=True) + default = object() + assert value.pop(path, default) is default + assert value.to_dict() == {"items": [{}, [{}]]} From d62f21fd15be2ab196080f0d2c334aa42663b555 Mon Sep 17 00:00:00 2001 From: fhgffy <102001626+fhgffy@users.noreply.github.com> Date: Sun, 11 Oct 2026 02:34:50 +0800 Subject: [PATCH 28/61] Honor explicit ensure_ascii options in JSON output --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ box/converters.py | 5 +++-- test/test_converters.py | 49 ++++++++++++++++++++++++++++++++++++++++- 4 files changed, 57 insertions(+), 3 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..dccb7e5 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,7 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- fhgffy Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..723f5d5 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Honor explicit ``ensure_ascii`` options in ``Box`` and ``BoxList`` JSON output. + Version 7.4.1 ------------- diff --git a/box/converters.py b/box/converters.py index bb91ba6..c986ea9 100644 --- a/box/converters.py +++ b/box/converters.py @@ -156,12 +156,13 @@ def _exists(filename: str | PathLike, create: bool = False) -> Path: def _to_json( obj, filename: str | PathLike | None = None, encoding: str = "utf-8", errors: str = "strict", **json_kwargs ): + json_kwargs.setdefault("ensure_ascii", False) if filename: _exists(filename, create=True) with open(filename, "w", encoding=encoding, errors=errors) as f: - json.dump(obj, f, ensure_ascii=False, **json_kwargs) + json.dump(obj, f, **json_kwargs) else: - return json.dumps(obj, ensure_ascii=False, **json_kwargs) + return json.dumps(obj, **json_kwargs) def _from_json( diff --git a/test/test_converters.py b/test/test_converters.py index d66b75b..5d66315 100644 --- a/test/test_converters.py +++ b/test/test_converters.py @@ -10,7 +10,7 @@ import pytest from ruamel.yaml import YAML -from box import BoxError +from box import Box, BoxError, BoxList from box.converters import _from_toml, _to_json, _to_msgpack, _to_toml, _to_yaml toml_string = """[movies.Spaceballs] @@ -75,6 +75,53 @@ def test_to_json(self): assert "Rick Moranis" in open(m_file).read() assert json.load(open(m_file)) == json.loads(movie_string) + @pytest.mark.parametrize("box_type", [Box, BoxList]) + @pytest.mark.parametrize("to_file", [False, True]) + @pytest.mark.parametrize( + "ensure_ascii, expected", + [ + (None, '{"café": "你好😀"}'), + (False, '{"café": "你好😀"}'), + (True, r'{"caf\u00e9": "\u4f60\u597d\ud83d\ude00"}'), + ], + ) + def test_to_json_ensure_ascii(self, box_type, to_file, ensure_ascii, expected, tmp_path): + data = {"café": "你好😀"} + if box_type is BoxList: + data = [data] + expected = f"[{expected}]" + value = box_type(data) + kwargs = {} if ensure_ascii is None else {"ensure_ascii": ensure_ascii} + + if to_file: + filename = tmp_path / "unicode.json" + encoding = "ascii" if ensure_ascii else "utf-8" + assert value.to_json(filename=filename, encoding=encoding, **kwargs) is None + actual = filename.read_text(encoding=encoding) + else: + actual = value.to_json(**kwargs) + + assert actual == expected + assert json.loads(actual) == data + + @pytest.mark.parametrize("ensure_ascii", [None, False, True]) + def test_to_json_multiline_ensure_ascii(self, ensure_ascii, tmp_path): + value = BoxList([{"text": "你好"}, {"text": "😀"}]) + kwargs = {} if ensure_ascii is None else {"ensure_ascii": ensure_ascii} + filename = tmp_path / "unicode.jsonl" + + assert value.to_json(filename=filename, multiline=True, **kwargs) is None + + expected = '{"text": "你好"}\n{"text": "😀"}' + if ensure_ascii: + expected = r'{"text": "\u4f60\u597d"}' + "\n" + r'{"text": "\ud83d\ude00"}' + assert filename.read_text(encoding="utf-8") == expected + + def test_to_json_ensure_ascii_with_other_options(self): + value = Box(z="你好", a=1) + + assert value.to_json(ensure_ascii=True, sort_keys=True, separators=(",", ":")) == r'{"a":1,"z":"\u4f60\u597d"}' + def test_to_yaml(self): m_file = os.path.join(tmp_dir, "movie_data") movie_string = _to_yaml(movie_data) From 646b20f389ad14578a604b55efaa932fff61dd6d Mon Sep 17 00:00:00 2001 From: Muneeb Sheikh Date: Sun, 11 Oct 2026 13:38:46 -0400 Subject: [PATCH 29/61] Allow same-key updates with duplicate conversion checks --- AUTHORS.rst | 2 ++ CHANGES.rst | 2 ++ box/box.py | 2 +- test/test_box.py | 22 ++++++++++++++++++++++ 4 files changed, 27 insertions(+), 1 deletion(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..c981509 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,6 +5,8 @@ reporting, all input is greatly appreciated! Code contributions: +- Muneeb Sheikh (muneikh) + - Alexandre Decan (AlexandreDecan) - dhilipsiva (dhilipsiva) - MAA (FooBarQuaxx) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..b45db98 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -4,6 +4,8 @@ Changelog Version 7.4.1 ------------- +* Allow reassigning an existing key when duplicate conversion checks are enabled. + * Fixing #303 Wrong version number (7.3.3) in 7.4.0 release (thanks to Michał Górny) Version 7.4.0 diff --git a/box/box.py b/box/box.py index 8252643..0f73078 100644 --- a/box/box.py +++ b/box/box.py @@ -957,7 +957,7 @@ def _conversion_checks(self, item): """ safe_item = self._safe_attr(item) - if safe_item in self._box_config["__safe_keys"]: + if safe_item in self._box_config["__safe_keys"] and self._box_config["__safe_keys"][safe_item] != item: dups = [f"{item}({safe_item})", f'{self._box_config["__safe_keys"][safe_item]}({safe_item})'] if self._box_config["box_duplicates"].startswith("warn"): warnings.warn(f"Duplicate conversion attributes exist: {dups}", BoxWarning) diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..f278f3d 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -7,6 +7,7 @@ import pickle import platform import shutil +import warnings from multiprocessing import Queue from pathlib import Path from io import StringIO @@ -28,6 +29,7 @@ from ruamel.yaml import YAML from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox, SBox, DDBox +from box.exceptions import BoxWarning from box.box import _get_dot_paths, _camel_killer, _recursive_tuples # type: ignore from box.converters import BOX_PARAMETERS @@ -630,6 +632,26 @@ def test_duplicate_errors(self): with pytest.raises(BoxError): my_box["^a"] = 3 + @pytest.mark.parametrize("policy", ["error", "warn"]) + @pytest.mark.parametrize("use_attribute", [False, True]) + def test_duplicate_checks_allow_reassigning_same_key(self, policy, use_attribute): + my_box = Box({"a b": 1}, box_duplicates=policy) + with warnings.catch_warnings(): + warnings.simplefilter("error", BoxWarning) + if use_attribute: + my_box.a_b = 2 + else: + my_box["a b"] = 2 + assert my_box.to_dict() == {"a b": 2} + assert my_box.a_b == 2 + if policy == "error": + with pytest.raises(BoxError): + my_box["a-b"] = 3 + assert my_box.to_dict() == {"a b": 2} + else: + with pytest.warns(BoxWarning): + my_box["a-b"] = 3 + def test_copy(self): my_box = Box(movie_data, camel_killer_box=True) bb = my_box.copy() From acc898469998236e166350c237a06ab5b97f6ab0 Mon Sep 17 00:00:00 2001 From: AryanRG Date: Sat, 17 Oct 2026 13:43:27 +0530 Subject: [PATCH 30/61] Accept source and keyword overrides in Box.update --- AUTHORS.rst | 1 + CHANGES.rst | 5 +++++ box/box.py | 4 ++-- test/test_box.py | 41 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 49 insertions(+), 2 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..74c01ce 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,7 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- AryanRG (AryanRG) Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..4b04e9e 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,11 @@ Changelog ========= +Unreleased +---------- + +* Fix ``Box.update`` rejecting a positional mapping or iterable when keyword updates are also supplied. + Version 7.4.1 ------------- diff --git a/box/box.py b/box/box.py index 8252643..7e260b4 100644 --- a/box/box.py +++ b/box/box.py @@ -820,8 +820,8 @@ def to_dict(self) -> dict: def update(self, *args, **kwargs): if self._box_config["frozen_box"]: raise BoxError("Box is frozen") - if (len(args) + int(bool(kwargs))) > 1: - raise BoxTypeError(f"update expected at most 1 argument, got {len(args) + int(bool(kwargs))}") + if len(args) > 1: + raise BoxTypeError(f"update expected at most 1 argument, got {len(args)}") single_arg = next(iter(args), None) if single_arg: if hasattr(single_arg, "keys"): diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..defbfef 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -268,6 +268,47 @@ def test_update(self): assert a.key1.gg == 4 assert "new" not in a.key1.keys() + @pytest.mark.parametrize("source_type", [dict, list, iter]) + def test_update_source_and_keywords(self, source_type): + pairs = [("mode", "source"), ("service", {"timeout": 10})] + overrides = {"mode": "override", "workers": [{"id": 1}]} + expected = {"keep": True} + expected.update(source_type(pairs), **overrides) + bx = Box(keep=True) + + assert bx.update(source_type(pairs), **overrides) is None + + assert bx.to_dict() == expected + assert isinstance(bx.service, Box) + assert bx.service.timeout == 10 + assert isinstance(bx.workers, BoxList) + assert isinstance(bx.workers[0], Box) + assert bx.workers[0].id == 1 + + def test_update_empty_source_and_keywords(self): + bx = Box(keep=True) + + assert bx.update({}, mode="override") is None + + assert bx.to_dict() == {"keep": True, "mode": "override"} + + @pytest.mark.parametrize("kwargs", [{}, {"mode": "override"}]) + def test_update_rejects_multiple_sources(self, kwargs): + bx = Box(keep=True) + + with pytest.raises(TypeError, match="update expected at most 1 argument"): + bx.update({"first": 1}, {"second": 2}, **kwargs) + + assert bx.to_dict() == {"keep": True} + + def test_update_source_and_keywords_frozen(self): + bx = Box(keep=True, frozen_box=True) + + with pytest.raises(BoxError, match="Box is frozen"): + bx.update({"first": 1}, mode="override") + + assert bx.to_dict() == {"keep": True} + def test_merge_update(self): a = Box(test_dict) a.grand = 1000 From a85b237f37a88ca7bc3da2412b09eee804096424 Mon Sep 17 00:00:00 2001 From: Gary <182863204+gary1110086@users.noreply.github.com> Date: Wed, 28 Oct 2026 16:09:17 +0800 Subject: [PATCH 31/61] Release converted attribute aliases after deleting keys --- AUTHORS.rst | 1 + CHANGES.rst | 2 ++ box/box.py | 6 +++++- test/test_box.py | 31 +++++++++++++++++++++++++++++++ 4 files changed, 39 insertions(+), 1 deletion(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..680a22e 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,6 +5,7 @@ reporting, all input is greatly appreciated! Code contributions: +- Gary (gary1110086) - Alexandre Decan (AlexandreDecan) - dhilipsiva (dhilipsiva) - MAA (FooBarQuaxx) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..1dadc02 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -4,6 +4,8 @@ Changelog Version 7.4.1 ------------- +* Release converted attribute aliases when keys are deleted or popped. + * Fixing #303 Wrong version number (7.3.3) in 7.4.0 release (thanks to Michał Górny) Version 7.4.0 diff --git a/box/box.py b/box/box.py index 8252643..5c4b070 100644 --- a/box/box.py +++ b/box/box.py @@ -724,6 +724,11 @@ def __delitem__(self, key): super().__delitem__(key) except KeyError as err: raise BoxKeyError(str(err)) from _exception_cause(err) + if self._box_config["conversion_box"]: + safe_key = self._safe_attr(key) + safe_keys = self._box_config["__safe_keys"] + if safe_key in safe_keys and safe_keys[safe_key] == key: + del safe_keys[safe_key] def __delattr__(self, item): if self._box_config["frozen_box"]: @@ -746,7 +751,6 @@ def __delattr__(self, item): safe_key = self._safe_attr(item) if safe_key in self._box_config["__safe_keys"]: self.__delitem__(self._box_config["__safe_keys"][safe_key]) - del self._box_config["__safe_keys"][safe_key] return raise BoxKeyError(str(err)) from _exception_cause(err) diff --git a/test/test_box.py b/test/test_box.py index e5c56e0..937ed1f 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -54,6 +54,37 @@ def temp_dir_cleanup(self): yield shutil.rmtree(str(tmp_dir), ignore_errors=True) + @pytest.mark.parametrize("removal", ["item", "attribute", "converted_attribute", "pop", "popitem"]) + def test_removed_key_releases_conversion_alias(self, removal): + bx = Box({"a b": 1}, box_duplicates="error") + if removal == "item": + del bx["a b"] + elif removal == "attribute": + delattr(bx, "a b") + elif removal == "converted_attribute": + del bx.a_b + elif removal == "pop": + bx.pop("a b") + else: + bx.popitem() + + bx["a-b"] = 2 + assert bx.to_dict() == {"a-b": 2} + assert bx.a_b == 2 + with pytest.raises(BoxError): + bx["a b"] = 3 + + def test_deleting_none_key_after_conversion_alias_owner(self): + bx = Box({None: 1, "None": 2}) + del bx["None"] + del bx[None] + assert bx.to_dict() == {} + + def test_deleting_colliding_key_keeps_other_conversion_alias(self): + bx = Box({"a b": 1, "a-b": 2}) + del bx["a b"] + assert bx.a_b == 2 + def test_safe_attrs(self): assert Box()._safe_attr("BAD!KEY!1") == "BAD_KEY_1" assert Box(camel_killer_box=True)._safe_attr("BAD!KEY!2") == "bad_key_2" From 8f1be45698ed6b629bb657307797b3ebfd18fa30 Mon Sep 17 00:00:00 2001 From: Abhinav Maurya Date: Thu, 29 Oct 2026 08:04:03 +0530 Subject: [PATCH 32/61] Fix pickling of frozen BoxList instances (#344) --- AUTHORS.rst | 1 + CHANGES.rst | 2 ++ box/box_list.py | 10 ++++----- test/test_box_list.py | 49 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 57 insertions(+), 5 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851..4c06d6e 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,7 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- Abhinav Maurya (Fire162) Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..130a60b 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,8 @@ Changelog ========= +* Fixing #344 Frozen BoxList instances cannot be pickled (thanks to Abhinav Maurya) + Version 7.4.1 ------------- diff --git a/box/box_list.py b/box/box_list.py index 72609ff..2e3c327 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -35,6 +35,10 @@ _list_pos_re = re.compile(r"\[(\d+)\]") +def _frozen_box_list_method(*args, **kwargs): + raise BoxError("BoxList is frozen") + + class BoxList(list): """ Drop in replacement of list, that converts added objects to Box or BoxList @@ -58,12 +62,8 @@ def __init__(self, iterable: Iterable | None = None, box_class: type[box.Box] = self.append(x) self.box_org_ref = None if box_options.get("frozen_box"): - - def frozen(*args, **kwargs): - raise BoxError("BoxList is frozen") - for method in ["append", "extend", "insert", "pop", "remove", "reverse", "sort"]: - self.__setattr__(method, frozen) + self.__setattr__(method, _frozen_box_list_method) def __getitem__(self, item): if self.box_options.get("box_dots") and isinstance(item, str) and item.startswith("["): diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e0..e0bd071 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -4,6 +4,7 @@ import json import os +import pickle import shutil import sys import platform @@ -74,6 +75,54 @@ def test_frozen_list(self): bl2[1] = 4 assert bl2[1] == 4 + def test_frozen_list_pickle(self): + for protocol in range(pickle.HIGHEST_PROTOCOL + 1): + bl = BoxList([5, 4, 3], frozen_box=True) + dumped = pickle.dumps(bl, protocol=protocol) + loaded = pickle.loads(dumped) + assert loaded == [5, 4, 3] + assert loaded.box_options.get("frozen_box") is True + with pytest.raises(BoxError): + loaded.append(2) + with pytest.raises(BoxError): + loaded.extend([1]) + with pytest.raises(BoxError): + loaded.pop(0) + with pytest.raises(BoxError): + loaded.remove(5) + with pytest.raises(BoxError): + loaded.insert(0, 9) + with pytest.raises(BoxError): + loaded.reverse() + with pytest.raises(BoxError): + loaded.sort() + with pytest.raises(BoxError): + del loaded[0] + with pytest.raises(BoxError): + loaded[0] = 99 + + empty_bl = BoxList([], frozen_box=True) + empty_dumped = pickle.dumps(empty_bl, protocol=protocol) + empty_loaded = pickle.loads(empty_dumped) + assert empty_loaded == [] + assert empty_loaded.box_options.get("frozen_box") is True + with pytest.raises(BoxError): + empty_loaded.append(1) + + def test_box_list_pickle(self): + for protocol in range(pickle.HIGHEST_PROTOCOL + 1): + bl = BoxList([1, 2, 3]) + dumped = pickle.dumps(bl, protocol=protocol) + loaded = pickle.loads(dumped) + assert loaded == [1, 2, 3] + assert not loaded.box_options.get("frozen_box") + loaded.append(4) + assert loaded == [1, 2, 3, 4] + loaded[0] = 9 + assert loaded[0] == 9 + del loaded[0] + assert loaded == [2, 3, 4] + def test_box_list_to_json(self): bl = BoxList([{"item": 1, "CamelBad": 2}]) assert json.loads(bl.to_json())[0]["item"] == 1 From 89f7231bc31757a4072f42a7006cfc41ced615f5 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 19:37:37 -0500 Subject: [PATCH 33/61] Prep 7.5.0: add Python 3.15, drop 3.10 - Add Python 3.15 to test matrix, classifiers and Cython wheel builds - Add manylinux wheels for cp314 and cp315 (cp314 was missing) - Fix python_requires (was still >=3.9) to >=3.11 - Remove now-dead tomli python_version<3.11 requirements - Require Cython>=3.3.0 (first release with 3.15 support) - Bump actions/checkout, setup-python, upload-artifact to v7 - Bump version to 7.5.0 Co-Authored-By: Claude Opus 5.5 --- .github/workflows/pythonpublish.yml | 28 ++++++++++++------------ .github/workflows/tests.yml | 34 ++++++++++++++--------------- CHANGES.rst | 9 ++++++++ box/__init__.py | 2 +- requirements-dev.txt | 2 +- requirements-test.txt | 1 - requirements.txt | 1 - setup.py | 6 ++--- 8 files changed, 45 insertions(+), 38 deletions(-) diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index e385f04..b11d5f0 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -13,12 +13,12 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v7 - name: Set up Python - uses: actions/setup-python@v5 + uses: actions/setup-python@v7 with: - python-version: '3.14' + python-version: '3.15' - name: Install Dependencies run: | @@ -39,19 +39,19 @@ jobs: strategy: matrix: os: [macos-latest, windows-latest] - python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"] + python-version: ["3.11", "3.12", "3.13", "3.14", "3.15"] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v7 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v5 + uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip - pip install setuptools wheel twine Cython>=3.0.11 --upgrade + pip install setuptools wheel twine Cython>=3.3.0 --upgrade - name: Build and publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} @@ -63,11 +63,11 @@ jobs: deploy-cython-manylinux: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 - - name: Set up Python 3.13 - uses: actions/setup-python@v5 + - uses: actions/checkout@v7 + - name: Set up Python 3.14 + uses: actions/setup-python@v7 with: - python-version: "3.13" + python-version: "3.14" - name: Build wheels run: | @@ -75,10 +75,10 @@ jobs: pip install cibuildwheel setuptools wheel python -m cibuildwheel --output-dir dist env: - CIBW_BUILD: cp310-manylinux_x86_64 cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 - CIBW_BEFORE_BUILD: pip install Cython>=3.0.11 setuptools wheel + CIBW_BUILD: cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64 cp315-manylinux_x86_64 + CIBW_BEFORE_BUILD: pip install Cython>=3.3.0 setuptools wheel CIBW_BUILD_FRONTEND: "build; args: --no-isolation" - CIBW_BEFORE_TEST: pip install -r requirements.txt -r requirements-test.txt setuptools wheel twine Cython>=3.0.11 + CIBW_BEFORE_TEST: pip install -r requirements.txt -r requirements-test.txt setuptools wheel twine Cython>=3.3.0 CIBW_BUILD_VERBOSITY: 1 CIBW_TEST_COMMAND: pytest {package}/test -vv diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index e06da9a..e95778f 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -13,13 +13,13 @@ jobs: package-checks: strategy: matrix: - python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "pypy-3.11"] + python-version: ["3.11", "3.12", "3.13", "3.14", "3.15", "pypy-3.11"] os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v7 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v5 + uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} # - uses: actions/cache@v3 @@ -31,7 +31,7 @@ jobs: python -m pip install --upgrade pip pip install -r requirements.txt pip install -r requirements-test.txt - pip install coveralls mypy setuptools wheel twine Cython>=3.0.11 + pip install coveralls mypy setuptools wheel twine Cython>=3.3.0 - name: Run mypy if: "!startsWith(matrix.python-version, 'pypy')" run: mypy box @@ -53,7 +53,7 @@ jobs: Remove-item box -recurse -force python -m pytest -vv - name: Upload wheel artifact - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7 with: name: python_box_${{matrix.os}}_${{ matrix.python-version }} path: dist/*.whl @@ -61,11 +61,11 @@ jobs: package-manylinux-checks: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 - - name: Set up Python 3.13 - uses: actions/setup-python@v5 + - uses: actions/checkout@v7 + - name: Set up Python 3.14 + uses: actions/setup-python@v7 with: - python-version: "3.13" + python-version: "3.14" # - uses: actions/cache@v3 # with: @@ -78,15 +78,15 @@ jobs: pip install cibuildwheel python -m cibuildwheel --output-dir dist env: - CIBW_BUILD: cp310-manylinux_x86_64 cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 - CIBW_BEFORE_BUILD: pip install Cython>=3.0.11 setuptools wheel + CIBW_BUILD: cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64 cp315-manylinux_x86_64 + CIBW_BEFORE_BUILD: pip install Cython>=3.3.0 setuptools wheel CIBW_BUILD_FRONTEND: "build; args: --no-isolation" - CIBW_BEFORE_TEST: pip install -r requirements.txt -r requirements-test.txt setuptools wheel twine Cython>=3.0.11 + CIBW_BEFORE_TEST: pip install -r requirements.txt -r requirements-test.txt setuptools wheel twine Cython>=3.3.0 CIBW_BUILD_VERBOSITY: 1 CIBW_TEST_COMMAND: pytest {package}/test -vv - name: Upload wheel artifact - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7 with: name: python_box_manylinux path: dist/*-manylinux*.whl @@ -94,13 +94,13 @@ jobs: test: strategy: matrix: - python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"] + python-version: ["3.11", "3.12", "3.13", "3.14", "3.15"] os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v7 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v5 + uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} # - uses: actions/cache@v3 @@ -112,7 +112,7 @@ jobs: python -m pip install --upgrade pip pip install -r requirements.txt pip install -r requirements-test.txt - pip install setuptools wheel Cython>=3.0.11 + pip install setuptools wheel Cython>=3.3.0 python setup.py build_ext --inplace - name: Test with pytest env: diff --git a/CHANGES.rst b/CHANGES.rst index c4a347d..e79216c 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,15 @@ Changelog ========= +Version 7.5.0 +------------- + +* Adding support for Python 3.15 +* Adding manylinux Cython wheels for Python 3.14 and 3.15 +* Fixing python_requires to match supported versions +* Updating GitHub Actions to latest major versions +* Removing support for Python 3.10 as it is EOL + Version 7.4.1 ------------- diff --git a/box/__init__.py b/box/__init__.py index 23ebd2e..ae2e435 100644 --- a/box/__init__.py +++ b/box/__init__.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- __author__ = "Chris Griffith" -__version__ = "7.4.1" +__version__ = "7.5.0" from box.box import Box from box.box_list import BoxList diff --git a/requirements-dev.txt b/requirements-dev.txt index 0a430f9..ad13ec7 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,6 +1,6 @@ # Files needed for pre-commit hooks black>=23.1.0 -Cython>=3.0.11 +Cython>=3.3.0 mypy>=1.0.1 pre-commit>=2.21.0 setuptools>=75.6.0 diff --git a/requirements-test.txt b/requirements-test.txt index 071ec6d..940b6e1 100644 --- a/requirements-test.txt +++ b/requirements-test.txt @@ -3,7 +3,6 @@ msgpack>=1.0 pytest>=7.1.3 pytest-cov<6.0.0 ruamel.yaml>=0.19.1 -tomli>=1.2.3; python_version < '3.11' tomli-w>=1.0.0 toon_format @ git+https://github.com/toon-format/toon-python.git types-PyYAML>=6.0.3 diff --git a/requirements.txt b/requirements.txt index 8a77de2..2309ca2 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,3 @@ msgpack>=1.0.0 ruamel.yaml>=0.19.1 -tomli>=1.2.3; python_version < '3.11' tomli-w diff --git a/setup.py b/setup.py index 3898da7..a474d45 100644 --- a/setup.py +++ b/setup.py @@ -45,17 +45,17 @@ py_modules=["box"], packages=["box"], ext_modules=extra, - python_requires=">=3.9", + python_requires=">=3.11", include_package_data=True, platforms="any", classifiers=[ "Programming Language :: Python", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", + "Programming Language :: Python :: 3.15", "Programming Language :: Python :: Implementation :: CPython", "Development Status :: 5 - Production/Stable", "Natural Language :: English", @@ -71,7 +71,7 @@ "yaml": ["ruamel.yaml>=0.19.1"], "ruamel.yaml": ["ruamel.yaml>=0.19.1"], "PyYAML": ["PyYAML"], - "tomli": ["tomli; python_version < '3.11'", "tomli-w"], + "tomli": ["tomli-w"], "toml": ["toml"], "msgpack": ["msgpack"], }, From 8d20ee5f9ae6e76790790da19a8367a623f31e4d Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 19:45:16 -0500 Subject: [PATCH 34/61] Consolidate 7.5.0 changelog and AUTHORS for merged PRs Co-Authored-By: Claude Opus 5.5 --- AUTHORS.rst | 21 +++++++++------------ CHANGES.rst | 20 ++++++++++++++++++++ 2 files changed, 29 insertions(+), 12 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index de8da5b..1346307 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,10 +5,6 @@ reporting, all input is greatly appreciated! Code contributions: -- fhgffy -- Muneeb Sheikh (muneikh) - -- Gary (gary1110086) - Alexandre Decan (AlexandreDecan) - dhilipsiva (dhilipsiva) - MAA (FooBarQuaxx) @@ -48,11 +44,16 @@ Code contributions: - shguild - fhgffy - AryanRG (AryanRG) - - -Documentation contributions: - +- Muneeb Sheikh (muneikh) +- Gary (gary1110086) +- Vitaliy Voloshin (vitalivo) +- x0Lazarus +- Huanyi Xie (xiehuanyi) - Likio3000 +- koriyoshi2041 +- binggao1230 +- apoorvdarshan +- chuenchen309 Suggestions and bug reporting: @@ -114,7 +115,3 @@ Suggestions and bug reporting: - d00m514y3r - Sébastien Weber (seb5g) - Ward Loos (wrdls) -- Vitaliy Voloshin (vitalivo) -- x0Lazarus - -- Huanyi Xie (xiehuanyi) diff --git a/CHANGES.rst b/CHANGES.rst index 4bbeca8..3cf8aab 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -8,6 +8,26 @@ Version 7.5.0 * Adding manylinux Cython wheels for Python 3.14 and 3.15 * Fixing python_requires to match supported versions * Updating GitHub Actions to latest major versions +* Fixing #260 nested boxes losing box_dots after pickle (thanks to DSeaStar) +* Fixing #265 unclear error for malformed BoxList bracket indices with box_dots (thanks to Arindam Sikder) +* Fixing #272 frozen_box with lists could not be serialized to YAML / JSON (thanks to apoorvdarshan) +* Fixing #300 CamelCase keys in dotted lookups with camel_killer_box (thanks to Guo Jiarui) +* Fixing #305 dotted keys lost with box_dots when a non-dotted key with the same prefix follows (thanks to J vanBemmel) +* Fixing #308 subclass of Box not preserved for nested boxes after unpickling (thanks to koriyoshi2041) +* Fixing #344 frozen BoxList instances could not be pickled (thanks to Abhinav Maurya) +* Fixing frozen BoxList could be mutated via clear, += and *= (thanks to Vitaliy Voloshin) +* Fixing BoxList.__deepcopy__ not preserving box options (thanks to chuenchen309) +* Fixing second dotted write into an existing BoxList element discarding data (thanks to binggao1230) +* Fixing dicts and lists assigned to BoxList items and slices not being converted (thanks to x0Lazarus) +* Fixing BoxList.extend(self) revisiting its own appended values (thanks to x0Lazarus) +* Fixing BoxList construction testing the truth value of the iterable (thanks to fhgffy) +* Fixing BoxList to_json / from_json multiline not working with strings (thanks to shguild) +* Fixing explicit ensure_ascii option being ignored in JSON output (thanks to fhgffy) +* Fixing Box.pop with an explicit default creating missing values with default_box (thanks to Huanyi Xie) +* Fixing Box.update not accepting a positional source and keyword overrides together like dict.update (thanks to AryanRG) +* Fixing duplicate conversion check raising when re-assigning the same key (thanks to Muneeb Sheikh) +* Fixing deleted keys not releasing their converted attribute alias (thanks to Gary) +* Fixing optional dependency installation examples in README (thanks to Likio3000) * Removing support for Python 3.10 as it is EOL Version 7.4.1 From 79fc501ba59d8e7aace2d4e30c8540679a133214 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 19:45:22 -0500 Subject: [PATCH 35/61] Fix stray changelog entry from #340 Co-Authored-By: Claude Opus 5.5 --- CHANGES.rst | 2 -- 1 file changed, 2 deletions(-) diff --git a/CHANGES.rst b/CHANGES.rst index 3cf8aab..f615ccf 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -33,8 +33,6 @@ Version 7.5.0 Version 7.4.1 ------------- -* Allow reassigning an existing key when duplicate conversion checks are enabled. - * Fixing #303 Wrong version number (7.3.3) in 7.4.0 release (thanks to Michał Górny) Version 7.4.0 From 599e1a39b84783a1be51f9a81e9b9b0810dd9071 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 19:46:25 -0500 Subject: [PATCH 36/61] Format merged tests with black, tidy #305 test comments Co-Authored-By: Claude Opus 5.5 --- test/test_box.py | 9 +++------ test/test_box_list.py | 3 +++ 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/test/test_box.py b/test/test_box.py index a8a9571..146f44e 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -460,8 +460,8 @@ def test_from_yaml_box_dots_dotted_key_before_non_dotted(self): """ Test for issue #305: Dotted keys read from YAML are lost with box_dots / default_box when the dotted key appears before a non-dotted key with the same prefix. - - This test documents the bug where a.b: c followed by a: {d: e} causes a.b to be lost. + + Previously a.b: c followed by a: {d: e} caused a.b to be lost. """ # Create a temporary YAML file with dotted key before non-dotted key yaml_content = """a.b: c @@ -479,13 +479,10 @@ def test_from_yaml_box_dots_dotted_key_before_non_dotted(self): assert bx1["a"]["d"] == "e" # Test with box_dots=True and default_box=True - # Expected behavior: a.b should be merged into a.b, so a.b == "c" and a.d == "e" - # Current bug: a.b is lost when it appears before a: + # a.b should be merged into a, so a.b == "c" and a.d == "e" bx2 = Box.from_yaml(filename=yaml_file, box_dots=True, default_box=True) assert "a" in bx2 assert bx2["a"]["d"] == "e" - # This assertion will fail until the bug is fixed: - # The dotted key a.b should be accessible as either a["b"] or via dotted notation assert "b" in bx2["a"], "Bug #305: a.b key is lost when it appears before a: in YAML" assert bx2["a"]["b"] == "c" diff --git a/test/test_box_list.py b/test/test_box_list.py index ede8956..c43e5ff 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -67,6 +67,7 @@ def __bool__(self): result = BoxList(Rows()) assert len(result) == 1 assert result[0].value == 1 + @pytest.mark.parametrize("values", [[], [1], [1, 2], [{"SomeKey": 3}, [4]]]) def test_extend_self(self, values, monkeypatch): data = BoxList(values, camel_killer_box=True) @@ -174,6 +175,7 @@ def test_box_list_pickle(self): assert loaded[0] == 9 del loaded[0] assert loaded == [2, 3, 4] + def test_deepcopy_preserves_box_options(self): import copy @@ -195,6 +197,7 @@ def test_deepcopy_preserves_box_options(self): with pytest.raises(BoxError): clone.append(1) assert hash(clone) == hash(frozen) + @pytest.mark.parametrize("index", [0, -1, "[0]", "[1]"]) @pytest.mark.parametrize("container", ["mapping", "sequence"]) def test_assigned_containers_are_converted(self, index, container): From 9a8b4ddf1a5476890e700a54af880d09671daf69 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 20:45:29 -0500 Subject: [PATCH 37/61] Bump version to 8.0.0 Co-Authored-By: Claude Sonnet 5.5 --- CHANGES.rst | 2 +- box/__init__.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGES.rst b/CHANGES.rst index f615ccf..28b43fc 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,7 +1,7 @@ Changelog ========= -Version 7.5.0 +Version 8.0.0 ------------- * Adding support for Python 3.15 diff --git a/box/__init__.py b/box/__init__.py index ae2e435..0f14c44 100644 --- a/box/__init__.py +++ b/box/__init__.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- __author__ = "Chris Griffith" -__version__ = "7.5.0" +__version__ = "8.0.0" from box.box import Box from box.box_list import BoxList From f732efdce60524157d5c9a5487a51e2d4c481b0a Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 20:47:30 -0500 Subject: [PATCH 38/61] Add _box_internal_attrs for internal-only attributes on Box subclasses (#269) Also make Box.copy() and __deepcopy__ return the same class instead of hardcoding Box; ConfigBox/SBox copy overrides are no longer needed. Co-Authored-By: Claude Sonnet 5.5 --- CHANGES.rst | 2 + README.rst | 36 +++++++ box/box.py | 34 +++++-- box/config_box.py | 6 -- box/shorthand_box.py | 6 -- test/test_box.py | 219 +++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 285 insertions(+), 18 deletions(-) diff --git a/CHANGES.rst b/CHANGES.rst index 28b43fc..58bded5 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -4,6 +4,7 @@ Changelog Version 8.0.0 ------------- +* Adding #269 internal-only attributes for Box subclasses via _box_internal_attrs (thanks to bwanshoom and gtkacz for the suggestion) * Adding support for Python 3.15 * Adding manylinux Cython wheels for Python 3.14 and 3.15 * Fixing python_requires to match supported versions @@ -27,6 +28,7 @@ Version 8.0.0 * Fixing Box.update not accepting a positional source and keyword overrides together like dict.update (thanks to AryanRG) * Fixing duplicate conversion check raising when re-assigning the same key (thanks to Muneeb Sheikh) * Fixing deleted keys not releasing their converted attribute alias (thanks to Gary) +* Fixing Box.copy() (and copy.copy / copy.deepcopy) returning a plain Box, ConfigBox or SBox instead of the same subclass * Fixing optional dependency installation examples in README (thanks to Likio3000) * Removing support for Python 3.10 as it is EOL diff --git a/README.rst b/README.rst index 233dfc7..f67d6ad 100644 --- a/README.rst +++ b/README.rst @@ -126,6 +126,42 @@ allowing for recursive dot notation access. `Box` also includes helper functions to transform it back into a `dict`, as well as into `JSON`, `YAML`, `TOML`, or `msgpack` strings or files. +Internal Attributes on Subclasses +--------------------------------- + +If you subclass `Box` and need attributes that are *not* part of the data (a source path, a cache, a +logger...), list their names in ``_box_internal_attrs``. Setting or deleting those names with attribute access +stores them on the instance, like a normal Python object, instead of in the dictionary. + +.. code:: python + + from box import Box + + class Config(Box): + _box_internal_attrs = ("source_path", "_cache") + + def __init__(self, *args, source_path=None, **kwargs): + super().__init__(*args, **kwargs) + self.source_path = source_path + self._cache = {} + + c = Config({"name": "app"}, source_path="/etc/app.yml") + c.source_path # '/etc/app.yml' + c.to_dict() # {'name': 'app'} + "source_path" in c # False + +Internal attributes are excluded from ``to_dict``, ``to_json``, ``to_yaml``, ``to_toml``, ``to_msgpack``, ``keys()``, +iteration, ``in``, ``len``, equality and hashing. They survive ``pickle``, and are carried over by ``copy()``, +``copy.copy`` (shared, shallow) and ``copy.deepcopy`` (deep copied). They can be set and deleted even on a +``frozen_box``, since they are not data. + +Things to keep in mind: + +* Nested boxes are created through your subclass (as `box_class` defaults to it), so every nested box gets its + own fresh internal attributes from ``__init__``, they are not shared with the parent. +* Only attribute access is affected. ``c["source_path"]`` still refers to the dictionary data, and if a data key + and an internal attribute share a name, attribute access returns the internal attribute. + Thanks ====== diff --git a/box/box.py b/box/box.py index e39f183..15168b7 100644 --- a/box/box.py +++ b/box/box.py @@ -195,10 +195,19 @@ class Box(dict): :param box_dots_exclude: optional regular expression for dotted keys to exclude :param box_class: change what type of class sub-boxes will be created as :param box_namespace: the namespace this (possibly nested) Box lives within + + Subclasses may set ``_box_internal_attrs`` to a tuple of attribute names that are stored on + the instance instead of in the dict data (see ``_box_internal_attrs`` below). """ _box_config: dict[str, Any] + #: Names that subclasses can list to keep "internal-only" attributes. + #: Setting or deleting one of these names with attribute access stores it on the + #: instance (``object.__setattr__``) rather than in the dict data, so it is never + #: exported, iterated, compared or hashed. See the "Internal Attributes" docs. + _box_internal_attrs: tuple[str, ...] = () + _protected_keys = [ "to_dict", "to_json", @@ -492,23 +501,32 @@ def get(self, key, default=NO_DEFAULT): return default return self[key] - def copy(self) -> Box: + def __copy_internals(self, new, deep=False, memo=None): + """Carry instance-only attributes listed in `_box_internal_attrs` over to `new`.""" + for name in self._box_internal_attrs: + if name in self.__dict__: + value = self.__dict__[name] + object.__setattr__(new, name, copy.deepcopy(value, memo) if deep else value) + return new + + def copy(self): config = self.__box_config() config.pop("box_namespace") # Detach namespace; it will be reassigned if we nest again - return Box(super().copy(), **config) + return self.__copy_internals(self.__class__(super().copy(), **config)) - def __copy__(self) -> Box: + def __copy__(self): return self.copy() - def __deepcopy__(self, memodict=None) -> Box: + def __deepcopy__(self, memodict=None): frozen = self._box_config["frozen_box"] config = self.__box_config() config["frozen_box"] = False - out = self._box_config["box_class"](**config) - memodict = memodict or {} + out = self.__class__(**config) + memodict = memodict if memodict is not None else {} memodict[id(self)] = out for k, v in self.items(): out[copy.deepcopy(k, memodict)] = copy.deepcopy(v, memodict) + self.__copy_internals(out, deep=True, memo=memodict) out._box_config["frozen_box"] = frozen return out @@ -739,6 +757,8 @@ def __setitem__(self, key, value): def __setattr__(self, key, value): if key == "_box_config": return object.__setattr__(self, key, value) + if key in self._box_internal_attrs: + return object.__setattr__(self, key, value) if self._box_config["frozen_box"] and self._box_config["__created"]: raise BoxError("Box is frozen") if key in self._protected_keys: @@ -781,6 +801,8 @@ def __delitem__(self, key): del safe_keys[safe_key] def __delattr__(self, item): + if item in self._box_internal_attrs: + return object.__delattr__(self, item) if self._box_config["frozen_box"]: raise BoxError("Box is frozen") if item == "_box_config": diff --git a/box/config_box.py b/box/config_box.py index 5f8ad55..bf98c88 100644 --- a/box/config_box.py +++ b/box/config_box.py @@ -125,9 +125,3 @@ def getfloat(self, item, default=None): def __repr__(self): return f"{self.__class__.__name__}({str(self.to_dict())})" - - def copy(self): - return ConfigBox(super().copy()) - - def __copy__(self): - return ConfigBox(super().copy()) diff --git a/box/shorthand_box.py b/box/shorthand_box.py index aecfcc5..1ab7e56 100644 --- a/box/shorthand_box.py +++ b/box/shorthand_box.py @@ -46,12 +46,6 @@ def toml(self) -> str: def __repr__(self): return f"{self.__class__.__name__}({self})" - def copy(self) -> SBox: - return SBox(super(SBox, self).copy()) - - def __copy__(self) -> SBox: - return SBox(super(SBox, self).copy()) - class DDBox(SBox): def __init__(self, *args, **kwargs): diff --git a/test/test_box.py b/test/test_box.py index 146f44e..8c55a8a 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -1796,3 +1796,222 @@ def test_pop_explicit_default_dotted_list_path(path): default = object() assert value.pop(path, default) is default assert value.to_dict() == {"items": [{}, [{}]]} + + +class _InternalBox(Box): + _box_internal_attrs = ("source_path", "_cache") + + def __init__(self, *args, source_path=None, **kwargs): + super().__init__(*args, **kwargs) + self.source_path = source_path + self._cache = {} + + +class _InternalConfigBox(ConfigBox): + _box_internal_attrs = ("meta",) + + +class _InternalSBox(SBox): + _box_internal_attrs = ("meta",) + + +def _make_internal(): + c = _InternalBox({"name": "app", "db": {"host": "x"}}, source_path="/etc/app.yml") + c._cache["hits"] = 1 + c.normal = "data" + return c + + +class TestInternalAttrs: + def test_not_in_data(self): + c = _make_internal() + assert c.source_path == "/etc/app.yml" + assert c.to_dict() == {"name": "app", "db": {"host": "x"}, "normal": "data"} + assert "source_path" not in c and "_cache" not in c + assert list(c) == ["name", "db", "normal"] + assert list(c.keys()) == ["name", "db", "normal"] + assert len(c) == 3 + assert c == {"name": "app", "db": {"host": "x"}, "normal": "data"} + assert c.__dict__["source_path"] == "/etc/app.yml" + + def test_exports(self): + c = _make_internal() + assert "source_path" not in c.to_json() and "_cache" not in c.to_json() + assert "source_path" not in c.to_yaml() + assert "source_path" not in c.to_toml() + assert "source_path" not in str(c) and "source_path" not in repr(c) + assert b"source_path" not in c.to_msgpack() + assert _InternalBox.from_json(c.to_json()).to_dict() == c.to_dict() + + def test_copy_variants(self): + c = _make_internal() + for name, clone in [ + ("copy", copy.copy(c)), + ("deepcopy", copy.deepcopy(c)), + (".copy()", c.copy()), + ("pickle", pickle.loads(pickle.dumps(c))), + ]: + assert type(clone) is _InternalBox, name + assert clone.source_path == "/etc/app.yml", name + assert clone._cache == {"hits": 1}, name + assert clone.to_dict() == c.to_dict(), name + assert copy.copy(c)._cache is c._cache + assert c.copy()._cache is c._cache + assert copy.deepcopy(c)._cache is not c._cache + assert type(pickle.loads(pickle.dumps(c)).db) is _InternalBox + + def test_deepcopy_memo(self): + shared = {"x": 1} + c = _InternalBox(a=1) + c._cache = {"one": shared, "two": shared} + d = copy.deepcopy(c) + assert d._cache["one"] is d._cache["two"] + assert d._cache["one"] is not shared + o2 = copy.deepcopy([c, c]) + assert o2[0] is o2[1] + assert o2[0]._cache["one"] is o2[0]._cache["two"] + + def test_deepcopy_self_reference_in_internal(self): + c = _InternalBox(a=1) + c._cache = {"owner": c} + d = copy.deepcopy(c) + assert d._cache["owner"] is d + + def test_copy_does_not_share_assignment(self): + c = _make_internal() + d = c.copy() + d.source_path = "other" + assert c.source_path == "/etc/app.yml" + + def test_unset_internal_is_not_copied(self): + class Plain(Box): + _box_internal_attrs = ("source_path",) + + c = Plain(a=1) + c.source_path = 1 + del c.source_path + assert "source_path" not in c.copy().__dict__ + assert "source_path" not in copy.deepcopy(c).__dict__ + + def test_delete(self): + c = _make_internal() + del c.source_path + assert not hasattr(c, "source_path") + with pytest.raises(AttributeError): + del c.source_path + assert c.to_dict()["name"] == "app" + + def test_frozen(self): + f = _InternalBox({"a": 1}, frozen_box=True) + f._cache["x"] = 1 + f.source_path = "ok" + assert f.source_path == "ok" + del f.source_path + with pytest.raises(BoxError): + f.a = 2 + with pytest.raises(BoxError): + del f.a + assert hash(f) == hash(_InternalBox({"a": 1}, frozen_box=True)) + g = f.copy() + assert g._cache == {"x": 1} + with pytest.raises(BoxError): + g.a = 3 + h = copy.deepcopy(f) + with pytest.raises(BoxError): + h.a = 3 + h.source_path = "still ok" + + def test_nested_fresh_internals(self): + c = _make_internal() + assert type(c.db) is _InternalBox + assert c.db.source_path is None + assert c.db._cache == {} + c.db._cache["k"] = 1 + assert c._cache == {"hits": 1} + c.new = {"deep": {"x": 1}} + assert type(c.new.deep) is _InternalBox and c.new.deep._cache == {} + + def test_name_collision(self): + c = _InternalBox({"source_path": "data-value"}, source_path="attr-value") + assert c.source_path == "attr-value" + assert c["source_path"] == "data-value" + assert c.to_dict() == {"source_path": "data-value"} + assert "source_path" in c + + def test_item_assignment_is_data(self): + c = _InternalBox() + c["source_path"] = 5 + assert c.to_dict() == {"source_path": 5} + assert c.source_path is None + + def test_internal_checked_before_protected_keys(self): + class Weird(Box): + _box_internal_attrs = ("items",) + + w = Weird(a=1) + w.items = "mine" + assert w.__dict__["items"] == "mine" + assert w.to_dict() == {"a": 1} + del w.items + + def test_no_internals_unaffected(self): + assert Box._box_internal_attrs == () + b = Box(a=1) + b.source_path = 3 + assert b.to_dict() == {"a": 1, "source_path": 3} + assert "source_path" not in b.__dict__ + del b.source_path + assert "source_path" not in b + assert type(copy.copy(b)) is Box and type(copy.deepcopy(b)) is Box + + def test_equality_and_hash_ignore_internals(self): + a = _InternalBox({"a": 1}, frozen_box=True, source_path="one") + b = _InternalBox({"a": 1}, frozen_box=True, source_path="two") + assert a == b and hash(a) == hash(b) + + def test_box_options_preserved_on_copy(self): + c = _InternalBox({"a-b": 1}, camel_killer_box=True, box_dots=True, source_path="p") + d = c.copy() + assert d._box_config["box_dots"] is True + assert d.source_path == "p" + assert copy.deepcopy(c)._box_config["camel_killer_box"] is True + + def test_configbox_subclass(self): + c = _InternalConfigBox({"key": "1"}) + c.meta = {"m": 1} + assert c.to_dict() == {"key": "1"} + for clone in (c.copy(), copy.copy(c), copy.deepcopy(c), pickle.loads(pickle.dumps(c))): + assert type(clone) is _InternalConfigBox + assert clone.meta == {"m": 1} + assert clone.int("key") == 1 + assert copy.copy(c).meta is c.meta + assert copy.deepcopy(c).meta is not c.meta + + def test_sbox_subclass(self): + c = _InternalSBox({"a": 1}) + c.meta = [1] + assert c.to_dict() == {"a": 1} + for clone in (c.copy(), copy.copy(c), copy.deepcopy(c), pickle.loads(pickle.dumps(c))): + assert type(clone) is _InternalSBox + assert clone.meta == [1] + + +def test_copy_preserves_subclass(): + class Sub(Box): + pass + + s = Sub({"a": {"b": 1}}, default_box=True) + assert type(s.copy()) is Sub + assert type(copy.copy(s)) is Sub + assert type(copy.deepcopy(s)) is Sub + assert s.copy()._box_config["default_box"] is True + assert type(Box(a=1).copy()) is Box + + +def test_copy_preserves_configbox_sbox_ddbox_types(): + for cls in (ConfigBox, SBox, DDBox): + b = cls({"a": 1}) + assert type(b.copy()) is cls + assert type(copy.copy(b)) is cls + assert type(copy.deepcopy(b)) is cls + assert b.copy() == b From 4ef86101a18264a82e13642d3e5dd52e29570f71 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 20:52:03 -0500 Subject: [PATCH 39/61] Fix PR #326 edge cases: stale children, frozen boxes, pickling, dotted keys - never overwrite a key that gained a real value after the ephemeral child was handed out - flush only when data is actually stored, so failed writes/deletes/frozen boxes never mutate the parent - strip the pending-parent reference from pickled state - do not create literal dotted keys for box_dots lookups; register conversion_box alias - Box.update also creates missing parents Co-Authored-By: Claude Sonnet 5.5 --- AUTHORS.rst | 1 + CHANGES.rst | 1 + box/box.py | 38 +++++++++--- test/test_box.py | 158 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 189 insertions(+), 9 deletions(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 1b41de4..581ab5c 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -56,6 +56,7 @@ Code contributions: - chuenchen309 - machines-6657 (machines-6657) - Chris (ChrisJr404) +- gyanu2507 (gyanu2507) Suggestions and bug reporting: diff --git a/CHANGES.rst b/CHANGES.rst index b1f5979..134fcef 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -5,6 +5,7 @@ Version 8.0.0 ------------- * BREAKING CHANGE: Box.popitem() now removes the most recently inserted item (LIFO) like dict.popitem(), instead of the first inserted item (thanks to machines-6657) +* Fixing #274 default_box_create_on_get=False not creating missing parent keys on assignment, e.g. box.a.b = 1 (thanks to gyanu2507 for the fix and wrdls for reporting) * Adding #263 "merge" option for box_merge_lists to merge lists of dictionaries element by element (thanks to ChrisJr404) * Adding #269 internal-only attributes for Box subclasses via _box_internal_attrs (thanks to bwanshoom and gtkacz for the suggestion) * Adding support for Python 3.15 diff --git a/box/box.py b/box/box.py index 25c7c8e..4bf8fa9 100644 --- a/box/box.py +++ b/box/box.py @@ -587,15 +587,17 @@ def __get_default(self, item, attr=False): if hasattr(self[first_item], "__setitem__"): self[first_item].__setitem__(children, value) else: + self._flush_pending_parent() super().__setitem__( first_item, self._box_config["box_class"](**self.__box_config(extra_namespace=first_item)) ) self[first_item].__setitem__(children, value) else: super().__setitem__(item, value) - elif isinstance(value, Box): + elif isinstance(value, Box) and not self.__process_dotted_key(item): # Lookups stay ephemeral, but a later assignment on this child - # should create the missing parent keys. + # should create the missing parent keys (see _flush_pending_parent). + # A strong reference is required: intermediate ephemeral parents are otherwise garbage collected. value._box_config["__pending_parent"] = (self, item) return value @@ -621,6 +623,7 @@ def __recast(self, item, value): return value def __convert_and_store(self, item, value): + self._flush_pending_parent() if self._box_config["conversion_box"]: safe_key = self._safe_attr(item) self._box_config["__safe_keys"][safe_key] = item @@ -733,17 +736,36 @@ def __getattr__(self, item): return value def _flush_pending_parent(self): + """ + With `default_box_create_on_get=False` a missing key returns an ephemeral child Box that is + not stored in its parent. The first time something is actually written to that child, attach it + (and any ephemeral ancestors) to the parent so `b.a.b = 1` creates `a`. + + Nothing is attached if the key has been given a real value since the child was handed out: the stale child is left detached rather than overwriting + data, so writes to it are lost just like any other ephemeral lookup. + """ pending = self._box_config.pop("__pending_parent", None) if pending is None: return parent, key = pending - parent_flush = getattr(parent, "_flush_pending_parent", None) - if parent_flush is not None: - parent_flush() + parent._flush_pending_parent() + if dict.__contains__(parent, key): + return + if parent._box_config["frozen_box"] and parent._box_config["__created"]: + raise BoxError("Box is frozen") + if parent._box_config["conversion_box"]: + parent._box_config["__safe_keys"][parent._safe_attr(key)] = key dict.__setitem__(parent, key, self) + def __getstate__(self): + # Ephemeral-child bookkeeping (a reference to the parent) must never be pickled + state = self.__dict__.copy() + config = state.get("_box_config") + if config is not None and "__pending_parent" in config: + state["_box_config"] = {k: v for k, v in config.items() if k != "__pending_parent"} + return state + def __setitem__(self, key, value): - self._flush_pending_parent() if key != "_box_config" and self._box_config["frozen_box"] and self._box_config["__created"]: raise BoxError("Box is frozen") if self.__process_dotted_key(key): @@ -752,6 +774,7 @@ def __setitem__(self, key, value): if hasattr(self[first_item], "__setitem__"): return self[first_item].__setitem__(children, value) elif self._box_config["default_box"]: + self._flush_pending_parent() if children[0] == "[": super().__setitem__(first_item, box.BoxList(**self.__box_config(extra_namespace=first_item))) else: @@ -770,8 +793,6 @@ def __setitem__(self, key, value): self.__convert_and_store(key, value) def __setattr__(self, key, value): - if key != "_box_config": - self._flush_pending_parent() if key == "_box_config": return object.__setattr__(self, key, value) if key in self._box_internal_attrs: @@ -792,7 +813,6 @@ def __setattr__(self, key, value): self.__setitem__(key, value) def __delitem__(self, key): - self._flush_pending_parent() if self._box_config["frozen_box"]: raise BoxError("Box is frozen") if key not in self.keys() and self.__process_dotted_key(key): diff --git a/test/test_box.py b/test/test_box.py index 1fe9476..a87ff46 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -2147,3 +2147,161 @@ class MyDict(dict): bx = Box({"m": [MyDict(a=1)]}, box_intact_types=(MyDict,)) bx.merge_update({"m": [{"b": 2}]}, box_merge_lists="merge") assert bx.m[0] == {"b": 2} + + +def _no_create_box(**kwargs): + return Box(default_box=True, default_box_create_on_get=False, **kwargs) + + +class TestCreateOnSetWithoutCreateOnGet: + def test_issue_274(self): + b = _no_create_box() + assert b.foo.bar == Box() + assert b == {} + b.foo.bar = 1 + assert b.to_dict() == {"foo": {"bar": 1}} + + def test_reads_never_create(self): + b = _no_create_box() + b.x.y.z + b["a"]["b"] + assert b == {} + + def test_deep_assignment_and_item_forms(self): + b = _no_create_box() + b.a.b.c.d = 1 + b["e"]["f"] = 2 + b.g.h.update({"i": 3}) + b.j.k.setdefault("l", 4) + b.m.merge_update({"n": 5}) + assert b.to_dict() == { + "a": {"b": {"c": {"d": 1}}}, + "e": {"f": 2}, + "g": {"h": {"i": 3}}, + "j": {"k": {"l": 4}}, + "m": {"n": 5}, + } + + def test_failed_operations_do_not_create(self): + b = _no_create_box() + with pytest.raises(BoxKeyError): + del b.x.nothing + with pytest.raises(BoxKeyError): + b.x.items = 1 # protected key + b.x.update({}) + assert b == {} + + def test_children_do_not_leak_bookkeeping(self): + b = _no_create_box() + child = b.x + assert "__pending_parent" in child._box_config + assert child.to_dict() == {} and repr(child) == "Box({})" + for clone in (copy.copy(child), copy.deepcopy(child), pickle.loads(pickle.dumps(child))): + assert "__pending_parent" not in clone._box_config + clone.z = 1 + assert b == {} + # box options handed to new children never include internal "__" keys + child.sub.q = 1 + assert child.to_dict() == {"sub": {"q": 1}} + assert not any(k.startswith("__pending") for k in child.sub._box_config["box_namespace"] if isinstance(k, str)) + # pickling a flushed child does not drag the old parent reference along + assert "__pending_parent" not in pickle.loads(pickle.dumps(b.x))._box_config + + def test_pickled_child_does_not_pickle_parent(self): + b = _no_create_box() + b.big = list(range(5000)) + child = b.x + assert len(pickle.dumps(child)) < 2000 + + def test_stale_child_does_not_clobber_scalar(self): + b = _no_create_box() + c = b.x + b.x = 5 + c.y = 1 + assert b.to_dict() == {"x": 5} + + def test_stale_child_does_not_clobber_dict(self): + b = _no_create_box() + c = b.x + b.x = {"q": 1} + c.y = 1 + assert b.to_dict() == {"x": {"q": 1}} + assert c.to_dict() == {"y": 1} + + def test_two_children_first_write_wins(self): + b = _no_create_box() + c1, c2 = b.x, b.x + c1.a = 1 + c2.b = 2 # stale: x already exists, detached child is not merged + assert b.to_dict() == {"x": {"a": 1}} + + def test_real_child_deleted_stays_detached(self): + b = _no_create_box() + b.x.y = 1 + c = b.x # a real, stored child + del b["x"] + c.z = 2 + assert b.to_dict() == {} + + def test_ephemeral_chain_with_stale_ancestor(self): + b = _no_create_box() + deep = b.a.b + b.a = {"keep": 1} + deep.c = 1 + assert b.to_dict() == {"a": {"keep": 1}} + + def test_frozen_is_never_mutated(self): + f = _no_create_box(frozen_box=True) + child = f.x + with pytest.raises(BoxError): + child.y = 1 + with pytest.raises(BoxError): + child["y"] = 1 + with pytest.raises(BoxError): + child.update(y=1) + assert f == {} + + def test_box_dots(self): + b = _no_create_box(box_dots=True) + b["a.b.c"] = 1 + b.d.e = 2 + assert b.to_dict() == {"a": {"b": {"c": 1}}, "d": {"e": 2}} + # dotted lookups stay ephemeral and never create a literal dotted key + c = b["z.y"] + c.k = 1 + assert "z.y" not in b.keys() + assert b.to_dict() == {"a": {"b": {"c": 1}}, "d": {"e": 2}} + + def test_conversion_box_alias_registered(self): + b = _no_create_box() + b["my key"].v = 1 + assert b.to_dict() == {"my key": {"v": 1}} + assert b.my_key.v == 1 + + def test_inside_boxlist(self): + b = _no_create_box(items_list=[{}]) + b.items_list[0].x.y = 1 + assert b.to_dict() == {"items_list": [{"x": {"y": 1}}]} + + def test_default_box_attr_dict(self): + b = _no_create_box(default_box_attr={"d": 1}) + b.x.d = 2 + assert b.to_dict() == {"x": {"d": 2}} + + def test_subclass_keeps_type(self): + class Sub(Box): + pass + + b = Sub(default_box=True, default_box_create_on_get=False) + b.x.y = 1 + assert type(b.x) is Sub + + def test_create_on_get_default_unchanged(self): + b = Box(default_box=True) + b.a.b + assert b.to_dict() == {"a": {"b": {}}} + assert "__pending_parent" not in b.a._box_config + + def test_no_default_box_unchanged(self): + with pytest.raises(BoxKeyError): + Box().x.y = 1 From 038ef7c2fdfd33958afbd7a0f36839e49b3068d7 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 20:57:39 -0500 Subject: [PATCH 40/61] Move package metadata to pyproject.toml (PEP 621) setup.py is reduced to the optional Cython ext_modules; Cython is deliberately not a build requirement so sdist installs stay pure Python. Dropped the stray py_modules=['box'] and platforms='any' (meaningless for compiled wheels). Co-Authored-By: Claude Sonnet 5.5 --- pyproject.toml | 58 ++++++++++++++++++++++++++++++++++++ setup.py | 80 +++++++++----------------------------------------- 2 files changed, 72 insertions(+), 66 deletions(-) create mode 100644 pyproject.toml diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..19b5568 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,58 @@ +[build-system] +# Cython is intentionally NOT listed here: a normal install (pip install python-box from an sdist) builds the +# pure Python version. To build the compiled version, install Cython in the build environment and build with +# `--no-isolation` (see CONTRIBUTING.rst). +requires = ["setuptools>=77"] +build-backend = "setuptools.build_meta" + +[project] +name = "python-box" +dynamic = ["version"] +description = "Advanced Python dictionaries with dot notation access" +readme = { file = "README.rst", content-type = "text/x-rst" } +license = "MIT" +license-files = ["LICENSE"] +authors = [{ name = "Chris Griffith", email = "chris@cdgriffith.com" }] +requires-python = ">=3.11" +dependencies = [] +classifiers = [ + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Programming Language :: Python :: 3.15", + "Programming Language :: Python :: Implementation :: CPython", + "Development Status :: 5 - Production/Stable", + "Natural Language :: English", + "Intended Audience :: Developers", + "Operating System :: OS Independent", + "Topic :: Utilities", + "Topic :: Software Development", + "Topic :: Software Development :: Libraries :: Python Modules", +] + +[project.urls] +Homepage = "https://github.com/cdgriffith/Box" +Changelog = "https://github.com/cdgriffith/Box/blob/master/CHANGES.rst" +Issues = "https://github.com/cdgriffith/Box/issues" + +[project.optional-dependencies] +all = ["ruamel.yaml>=0.19.1", "toml", "msgpack"] +yaml = ["ruamel.yaml>=0.19.1"] +"ruamel.yaml" = ["ruamel.yaml>=0.19.1"] +PyYAML = ["PyYAML"] +tomli = ["tomli-w"] +toml = ["toml"] +msgpack = ["msgpack"] + +[tool.setuptools] +packages = ["box"] +include-package-data = true + +[tool.setuptools.package-data] +box = ["py.typed", "*.pyi"] + +[tool.setuptools.dynamic] +version = { attr = "box.__version__" } diff --git a/setup.py b/setup.py index a474d45..c9b9a54 100644 --- a/setup.py +++ b/setup.py @@ -1,81 +1,29 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- +""" +All package metadata lives in pyproject.toml. + +This file only exists to optionally compile the library with Cython. If Cython is +installed in the build environment the modules are compiled, otherwise a pure Python +package is built (which is what happens with the default isolated build). +""" -# Must import multiprocessing as a fix for issues with testing, experienced on win10 -import multiprocessing # noqa: F401 -import os -import re -from pathlib import Path import sys -import shutil +from pathlib import Path from setuptools import setup -root = os.path.abspath(os.path.dirname(__file__)) +root = Path(__file__).resolve().parent try: from Cython.Build import cythonize except ImportError: - extra = None + ext_modules = [] + print("WARNING: Cython not installed, could not optimize box.", file=sys.stderr) else: - extra = cythonize( - [str(file.relative_to(root)) for file in Path(root, "box").glob("*.py") if file.name != "__init__.py"], + ext_modules = cythonize( + [str(file.relative_to(root)) for file in (root / "box").glob("*.py") if file.name != "__init__.py"], compiler_directives={"language_level": 3}, ) -with open(os.path.join(root, "box", "__init__.py"), "r") as init_file: - init_content = init_file.read() - -attrs = dict(re.findall(r"__([a-z]+)__ *= *['\"](.+)['\"]", init_content)) - -with open("README.rst", "r") as readme_file: - long_description = readme_file.read() - -setup( - name="python-box", - version=attrs["version"], - url="https://github.com/cdgriffith/Box", - license="MIT", - author=attrs["author"], - install_requires=[], - author_email="chris@cdgriffith.com", - description="Advanced Python dictionaries with dot notation access", - long_description=long_description, - long_description_content_type="text/x-rst", - py_modules=["box"], - packages=["box"], - ext_modules=extra, - python_requires=">=3.11", - include_package_data=True, - platforms="any", - classifiers=[ - "Programming Language :: Python", - "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.11", - "Programming Language :: Python :: 3.12", - "Programming Language :: Python :: 3.13", - "Programming Language :: Python :: 3.14", - "Programming Language :: Python :: 3.15", - "Programming Language :: Python :: Implementation :: CPython", - "Development Status :: 5 - Production/Stable", - "Natural Language :: English", - "Intended Audience :: Developers", - "License :: OSI Approved :: MIT License", - "Operating System :: OS Independent", - "Topic :: Utilities", - "Topic :: Software Development", - "Topic :: Software Development :: Libraries :: Python Modules", - ], - extras_require={ - "all": ["ruamel.yaml>=0.19.1", "toml", "msgpack"], - "yaml": ["ruamel.yaml>=0.19.1"], - "ruamel.yaml": ["ruamel.yaml>=0.19.1"], - "PyYAML": ["PyYAML"], - "tomli": ["tomli-w"], - "toml": ["toml"], - "msgpack": ["msgpack"], - }, -) - -if not extra: - print("WARNING: Cython not installed, could not optimize box.", file=sys.stderr) +setup(ext_modules=ext_modules) From 9d80d9c33d543485702394de5a639cb643d995fe Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:02:30 -0500 Subject: [PATCH 41/61] Replace requirements files and black with uv dependency groups and ruff config - [dependency-groups] test/dev in pyproject.toml (toon_format as a direct git reference), uv.lock added - [tool.ruff] (line length 120, py311, black compatible format; E/F/W/I lint), pre-commit uses ruff-pre-commit - coverage and cibuildwheel configuration moved into pyproject.toml - removed .black.toml, .coveragerc and requirements*.txt, dropped the no-op cythonize pre-commit hook Co-Authored-By: Claude Sonnet 5.5 --- .black.toml | 15 - .coveragerc | 28 - .pre-commit-config.yaml | 19 +- pyproject.toml | 85 +++ requirements-dev.txt | 7 - requirements-test.txt | 9 - requirements.txt | 3 - uv.lock | 1532 +++++++++++++++++++++++++++++++++++++++ 8 files changed, 1623 insertions(+), 75 deletions(-) delete mode 100644 .black.toml delete mode 100644 .coveragerc delete mode 100644 requirements-dev.txt delete mode 100644 requirements-test.txt delete mode 100644 requirements.txt create mode 100644 uv.lock diff --git a/.black.toml b/.black.toml deleted file mode 100644 index bedc251..0000000 --- a/.black.toml +++ /dev/null @@ -1,15 +0,0 @@ -[tool.black] -line-length = 120 -target-version = ['py37', 'py38', 'py39', 'py310', 'py311'] -exclude = ''' -/( - \.eggs - | \.git - | \.idea - | \.pytest_cache - | _build - | build - | dist - | venv -)/ -''' diff --git a/.coveragerc b/.coveragerc deleted file mode 100644 index 3d7adfa..0000000 --- a/.coveragerc +++ /dev/null @@ -1,28 +0,0 @@ -[report] -omit = - */python?.?/* - */site-packages/nose/* - */test/* - */pypy/* - */nose/* - */.*/* - */*.egg-info/* -exclude_lines = - pragma: no cover - raise err - except ImportError - yaml = none - raise BoxError\("_box_config key must exist - raise err - if "box_class" in self.__dict__: - raise BoxError\(f"File - except OSError - raise BoxError\(f"{filename} - item._box_config["__box_heritage"] = \(\) - raise BoxKeyError\(err - (.*)is unavailable on this system - def to_ - def from_ - warnings.warn - @classmethod - no package is available to open it diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index cee0904..a41dd5a 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -16,7 +16,6 @@ repos: # Python checks - id: check-docstring-first - id: debug-statements - - id: requirements-txt-fixer - id: fix-encoding-pragma - id: fix-byte-order-marker # General quality checks @@ -28,24 +27,18 @@ repos: - id: end-of-file-fixer exclude: ^test/data/.+ -- repo: https://github.com/ambv/black - rev: 24.10.0 +- repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.17.3 hooks: - - id: black - args: [--config=.black.toml] + - id: ruff-check + args: [--fix] + - id: ruff-format - repo: local hooks: - - id: cythonize-check - name: Cythonize - entry: pip install -e . - language: system - types: [python] - pass_filenames: false - # cythonize must come before the pytest to make sure we update all c code - id: pytest-check name: Check pytest - entry: pytest + entry: uv run --group test pytest language: system pass_filenames: false always_run: true diff --git a/pyproject.toml b/pyproject.toml index 19b5568..71c3484 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -56,3 +56,88 @@ box = ["py.typed", "*.pyi"] [tool.setuptools.dynamic] version = { attr = "box.__version__" } + +[dependency-groups] +# Everything the test suite needs (also used by cibuildwheel via `test-groups`) +test = [ + "coverage>=7.6.9", + "msgpack>=1.0", + "pytest>=7.1.3", + "pytest-cov<6.0.0", + "ruamel.yaml>=0.19.1", + "tomli-w>=1.0.0", + "toon_format @ git+https://github.com/toon-format/toon-python.git", + "types-PyYAML>=6.0.3", +] +# Development tooling: linting, type checking, building and releasing +dev = [ + { include-group = "test" }, + "build>=1.2", + "Cython>=3.3.0", + "mypy>=1.0.1", + "pre-commit>=2.21.0", + "ruff>=0.17.3", + "setuptools>=77", + "twine>=5", + "wheel>=0.34.2", +] + +[tool.ruff] +line-length = 120 +target-version = "py311" +extend-exclude = ["build", "dist", ".idea"] + +[tool.ruff.format] +# Black compatible defaults (double quotes, magic trailing comma, 88 -> 120 columns above) +quote-style = "double" +indent-style = "space" +skip-magic-trailing-comma = false +line-ending = "auto" + +[tool.ruff.lint] +# Deliberately conservative: pycodestyle, pyflakes and import sorting only +select = ["E", "F", "W", "I"] + +[tool.ruff.lint.isort] +# "test" is also a stdlib module name, make sure our test package is sorted with the first party code +known-first-party = ["box", "test"] + +[tool.cibuildwheel] +build = "cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64 cp315-manylinux_x86_64" +# Cython (and setuptools) must be present in the build environment, so build without isolation +before-build = "pip install Cython>=3.3.0 setuptools wheel" +build-frontend = { name = "build", args = ["--no-isolation"] } +build-verbosity = 1 +test-groups = ["test"] +test-command = "pytest {package}/test -vv" + +[tool.coverage.report] +omit = [ + "*/python?.?/*", + "*/site-packages/nose/*", + "*/test/*", + "*/pypy/*", + "*/nose/*", + "*/.*/*", + "*/*.egg-info/*", +] +exclude_lines = [ + "pragma: no cover", + "raise err", + "except ImportError", + "yaml = none", + 'raise BoxError\("_box_config key must exist', + "raise err", + "if \"box_class\" in self.__dict__:", + 'raise BoxError\(f"File', + "except OSError", + 'raise BoxError\(f"{filename}', + 'item._box_config["__box_heritage"] = \(\)', + 'raise BoxKeyError\(err', + "(.*)is unavailable on this system", + "def to_", + "def from_", + "warnings.warn", + "@classmethod", + "no package is available to open it", +] diff --git a/requirements-dev.txt b/requirements-dev.txt deleted file mode 100644 index ad13ec7..0000000 --- a/requirements-dev.txt +++ /dev/null @@ -1,7 +0,0 @@ -# Files needed for pre-commit hooks -black>=23.1.0 -Cython>=3.3.0 -mypy>=1.0.1 -pre-commit>=2.21.0 -setuptools>=75.6.0 -toon_format @ git+https://github.com/toon-format/toon-python.git diff --git a/requirements-test.txt b/requirements-test.txt deleted file mode 100644 index 940b6e1..0000000 --- a/requirements-test.txt +++ /dev/null @@ -1,9 +0,0 @@ -coverage>=7.6.9 -msgpack>=1.0 -pytest>=7.1.3 -pytest-cov<6.0.0 -ruamel.yaml>=0.19.1 -tomli-w>=1.0.0 -toon_format @ git+https://github.com/toon-format/toon-python.git -types-PyYAML>=6.0.3 -wheel>=0.34.2 diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 2309ca2..0000000 --- a/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -msgpack>=1.0.0 -ruamel.yaml>=0.19.1 -tomli-w diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..4bc940d --- /dev/null +++ b/uv.lock @@ -0,0 +1,1532 @@ +version = 1 +revision = 5 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version < '3.15'", +] + +[[package]] +name = "ast-serialize" +version = "0.13.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/d5/5dc1ee8a80c3b20a0b63c61b43ba6bc53517faecd1def47bcd752d22268e/ast_serialize-0.13.1.tar.gz", hash = "sha256:401cc84e8888d4d76f2c8d296fa006ed1a5ff993b6aff90dd777c03973efd025", size = 955137, upload-time = "2026-10-17T00:04:17.183Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/a8/fbd136b9f70c59e75f59a8e974c84102976f1201828b4f886480ba956936/ast_serialize-0.13.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:3e129d44b0cffbea24a7f40117ce49e30993c3d119e584d4817ebd6f87246456", size = 897306, upload-time = "2026-10-17T00:02:52.479Z" }, + { url = "https://files.pythonhosted.org/packages/50/3f/2ad51e9823a790e7a70fd781e9595ab3abeace27f3aefcaa1939457efd72/ast_serialize-0.13.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:523d45bab16ddaf1399c04c4fe81bbf180f81e33c2f7bcbe76be56b0f7311ab4", size = 1236082, upload-time = "2026-10-17T00:02:54.82Z" }, + { url = "https://files.pythonhosted.org/packages/c0/5c/8e959db5cc2237f9d4c560a8e2253c98f9746883fb4774651e4cda458901/ast_serialize-0.13.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:638333fb8ae72c62753f9e794fda20290883ddc65b0d85e26e08f8bb227567ad", size = 1221242, upload-time = "2026-10-17T00:02:56.395Z" }, + { url = "https://files.pythonhosted.org/packages/d6/05/ab1c56c3b7adcac88764bba609502d6b4989e449b2dd60eb478e1d20e369/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc34c670747d85d4232834665e247009413eaebe47c69eaf60a5c439aaecaed9", size = 1282105, upload-time = "2026-10-17T00:02:58.275Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f4/41981fcd2ddffe0760e5326be9dcbd2eda9478a8430a637e5123bd8fcb26/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8c8ebd419811c435812d242fb2a173e57dfede198c9ac9a0a584666ebc9b9331", size = 1287905, upload-time = "2026-10-17T00:03:00.068Z" }, + { url = "https://files.pythonhosted.org/packages/6a/43/b783addc5681153707121991b7b47892f7e9c8ba58a0d03b71a3b023ba47/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8899c038b1c15ae8b98e379057fb3ef398ceb0b21d1737a8156dd5a0923b7e51", size = 1541806, upload-time = "2026-10-17T00:03:01.503Z" }, + { url = "https://files.pythonhosted.org/packages/47/10/969db095038ee15270f65ad20d1129c5e4da605bf7e93b70ae640f1c8a9f/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e14c4de98f965647a74e6eaf37e20207124e45451ccd36e84a6f6ebab45e0372", size = 1309946, upload-time = "2026-10-17T00:03:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/06/dd/7c623d2fb0b868948952d1787e629a43b866f7d4caefd5445e20aefacec4/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f3e8a3eff69af640db985360fef35073fb46956dfc3e5c614cf00920d2746dd", size = 1302773, upload-time = "2026-10-17T00:03:04.378Z" }, + { url = "https://files.pythonhosted.org/packages/d4/c2/4d49469110a19a44fc6269f4fd59679bcf84df068f185f89b73bee4da19b/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:75d7750fe98f6f35a96c43aba8d98a2e623e22c778a0c17ab9ede92eb10f5d82", size = 1299579, upload-time = "2026-10-17T00:03:05.88Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9a/2d381f1f262dda15affc8ad643fba1619eb07e7d9f8bd904deffef183006/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43e8ddd63e80fc280c2f790157386f27f9b9f6ccb9c4f8e803b863cbfb085769", size = 1355969, upload-time = "2026-10-17T00:03:07.321Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9c/2266794e6c25fa9ce51ce04a9bf4b7e330e3ac9351ba3fa14e487678acdb/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9221e09496fb942901993c1812ee87950cc0ecbb514c7c0f1f5fa6d78f701ed8", size = 1460227, upload-time = "2026-10-17T00:03:08.733Z" }, + { url = "https://files.pythonhosted.org/packages/2b/d6/14deb28e5d8f328f626a0778ea2cf98fe908f2bbcccd804cb6f449ee1782/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:7a5c38bdb93669c596f94fb7204dd6ebe4fadb19058ac9a2faf2948c2a175f96", size = 1562691, upload-time = "2026-10-17T00:03:10.25Z" }, + { url = "https://files.pythonhosted.org/packages/f5/19/7a28c0e5ba54f0d3e054f847a2a549b748cb179ab433321a8dc1b39e398d/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:acf4e9f055d75058ab01536da330648746f2f82b7697a85230547f2d5ebe895c", size = 1558669, upload-time = "2026-10-17T00:03:11.799Z" }, + { url = "https://files.pythonhosted.org/packages/18/9a/f9e2690eab58217f1d395a964a78efa7eaf813a1e38be8dfd9a8d45d0840/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:87427913c325adc811e81e7c9a757b061f47ef1e29114ac479aa0953a2687a98", size = 1665071, upload-time = "2026-10-17T00:03:13.284Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f3/ef5b159a0d7161b404f05e7ec21cf7735ee7edc10c000cd2cbbc7bb6b69a/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:ad88921f95b92bc144d9ad059a0e16f8c1ae69f5239f2d3c6536fd2774f73dfe", size = 1473364, upload-time = "2026-10-17T00:03:14.563Z" }, + { url = "https://files.pythonhosted.org/packages/1d/87/6e8ac4a865124a12cc4f915bf1bcfac3bba426cd5f58d3712a873ee61012/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f8b17e2921e56621bcb46792bd3e0b82ca3b85de78d5936e7b8174ba1758b0aa", size = 1500566, upload-time = "2026-10-17T00:03:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/f5/1e/29155f1621433008013ad5c940a03d41a676be0680c41527040472d37583/ast_serialize-0.13.1-cp314-cp314t-win32.whl", hash = "sha256:2f9a9ce8b0994f757b941f7f7fe384a6666b4162b941ebc5c248081baea18e47", size = 1128674, upload-time = "2026-10-17T00:03:17.481Z" }, + { url = "https://files.pythonhosted.org/packages/bb/64/2506da65143ea138de5822e9173e0b72320a2f70e23bd723f044033175f1/ast_serialize-0.13.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5d99910e6b9a9b9360bcca2ae99aee36cc912ce058df2a57d1c33099b6cb2593", size = 1163306, upload-time = "2026-10-17T00:03:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/6d/8f/c7cb22638899b0cf15908809c270560e46395e65604bc59e4b623ab9f405/ast_serialize-0.13.1-cp314-cp314t-win_arm64.whl", hash = "sha256:a789cbe14d0a0e9ec9b32a456e5abc81ad8799479c3cfd88a29e3442262aebe6", size = 1133775, upload-time = "2026-10-17T00:03:20.377Z" }, + { url = "https://files.pythonhosted.org/packages/2b/e2/b0c140fe50fa39dd249e382f7733af6f816c90021fe7959a0b026f86237f/ast_serialize-0.13.1-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:23d768369b89d551077dc173da6892fad00443338417523b6732f4e8ba4a7ed5", size = 1236160, upload-time = "2026-10-17T00:03:21.945Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/a8a2ca21e3943555b48221f8fba546877a7ad39efaf6505506524967d7c4/ast_serialize-0.13.1-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:68f8829d114dab6c9db4a8bbb8d0e342958faee1b5e15a29022678df639960f8", size = 1222214, upload-time = "2026-10-17T00:03:23.462Z" }, + { url = "https://files.pythonhosted.org/packages/15/19/2f58f2ba64e4799b39de85c140aef09a03aa6ea53be75dd292a9d9b9d8ae/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e385b17d5bde892a6184003a9aff3518387908b73f8f5ea539313c07c8c0ede", size = 1282979, upload-time = "2026-10-17T00:03:24.695Z" }, + { url = "https://files.pythonhosted.org/packages/b1/af/ca6087fe84210c1ccd43e3182917bb70649fa1e69745a90c1d59ba08fea8/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:02686b281ec9b8e9614f6f0db27e12e4cac515f336c5d05b678bc9eb73ff2af5", size = 1288596, upload-time = "2026-10-17T00:03:26.04Z" }, + { url = "https://files.pythonhosted.org/packages/b0/2c/4ef964c763329a0347125e745ec0451ba4fbaceec9efe2ac729b7cd55f17/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a8ab2c2585b2e22e48cd4aff2136fce4eab4ced569b85f150ef9a5a5d6f34d49", size = 1545540, upload-time = "2026-10-17T00:03:27.52Z" }, + { url = "https://files.pythonhosted.org/packages/bb/85/aa961dbb75813cfa94de0ce9a16a9510c226b95f604c405421e727f44bb0/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c652d9f5d52d8b81eff3ff2c95c9dd0f281de45f6ad5d3fa95527550c396454a", size = 1309374, upload-time = "2026-10-17T00:03:29.091Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e6/f2b67c327d9f9533e41791804403ccc2dc457821195a2e51f0b587a90b90/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:121e1d08d58b75c15491cc3003609cbad71ac2b0016043c36d30a6b2032b6605", size = 1303466, upload-time = "2026-10-17T00:03:30.451Z" }, + { url = "https://files.pythonhosted.org/packages/73/1d/33f18b81d1bb1f5d682943ea92fda8130a6593627f12f6201668d40824fd/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:30cf89b6a6844542d116c758725d13de5b97b9410a51ee577715f761270d0c1c", size = 1300576, upload-time = "2026-10-17T00:03:32.102Z" }, + { url = "https://files.pythonhosted.org/packages/25/cb/64914144925f1a4abdd9217e717b122255c38fc5ebe4342f92052f3bacbc/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:732aaae9e498c973fc63fd7f308009b57c4afa6ff59d0b674d894e57d0bca01a", size = 1355960, upload-time = "2026-10-17T00:03:33.676Z" }, + { url = "https://files.pythonhosted.org/packages/ee/80/bd29379fab2bce19adc0bf9177002b11b23dfe8d8fecf409998b458b4624/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:d9c1a920b2aa0c1e016bed7721689717034ca0dba64ac3a3ff243b003d4e8dd8", size = 1459779, upload-time = "2026-10-17T00:03:35.09Z" }, + { url = "https://files.pythonhosted.org/packages/83/89/012dbe733de05ffdf8e40ca0f9fa5d417cb16ec93a74463c57c001914198/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:847cad4c22953823f5e76d0b126c6f9da670cfa45b1df41b9324e22189d77611", size = 1563399, upload-time = "2026-10-17T00:03:37.285Z" }, + { url = "https://files.pythonhosted.org/packages/69/37/ee4bcb0358bee38744eb0f18560446572d095fe3bf6b63d6f739d08a839c/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_i686.whl", hash = "sha256:aca07de3ca8e3d9f2b716c3c31f4f384fe4bd2d03e09912417cff7a3e08036f7", size = 1558808, upload-time = "2026-10-17T00:03:38.711Z" }, + { url = "https://files.pythonhosted.org/packages/54/1c/ff44c5355251d61ef22934c4430bb31a61de4781d25a992154aac9b8c82a/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:5db12d843d931b9d1f1519ce66b9cbfe72d8563b75c1204d255322254d1964dd", size = 1666324, upload-time = "2026-10-17T00:03:40.376Z" }, + { url = "https://files.pythonhosted.org/packages/c8/bb/6da4bfc8aa3403e6447607131bf3463acaf954d990c6c8b6787c1902ddfe/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:fb8021f4dc3296de18737e3b8b34994411da725374d74a0b9eb32a738f2a23d0", size = 1474089, upload-time = "2026-10-17T00:03:41.715Z" }, + { url = "https://files.pythonhosted.org/packages/21/97/897e33bef2eefd880e6350e375cc66bc5bcd00a139be480fd655f5b3f095/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:0d764913374ba21df8cd618045b371ed104ce55c6276de7c59e554a4f5ba26fd", size = 1501542, upload-time = "2026-10-17T00:03:43.08Z" }, + { url = "https://files.pythonhosted.org/packages/8d/4c/821211ac83870c27e4412381b7c7838336456b40575bf840e4680b2018d9/ast_serialize-0.13.1-cp315-abi3.abi3t-win32.whl", hash = "sha256:2bad302ae2427454ef9dab71bd5c3ad67188860c39d36daee38f72031edb39c4", size = 1126118, upload-time = "2026-10-17T00:03:44.616Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/2b2d5e6c4fa352874a80618e742ffd32d249dee6c119f4233b51afc6b8f4/ast_serialize-0.13.1-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:032b09d86c785c3984e975378b7861f2a68ac44e22ba7b07b93a536b2524eeb8", size = 1163766, upload-time = "2026-10-17T00:03:45.986Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/d610cfcdabaa44fd62a54ca1fc57a7dba120643798b089a14914973562de/ast_serialize-0.13.1-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:929eda0c419e622ab49df3a4c45f81c57dcc10874bbad55d0470a4a03324dac3", size = 1134043, upload-time = "2026-10-17T00:03:48.453Z" }, + { url = "https://files.pythonhosted.org/packages/f0/89/0e30f9eddf7d44ccf9d25979030754fd0457af61fa4279acb8c293a04f97/ast_serialize-0.13.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:bf53a3ba1cbe45399fc1e4ccd684b8f2a11cca450f89706b79122f478534c6f5", size = 897546, upload-time = "2026-10-17T00:03:50.093Z" }, + { url = "https://files.pythonhosted.org/packages/81/92/d705be88ff452b9ba0088b554a0cbd308fd01879da092b33fd2ad7d1aa60/ast_serialize-0.13.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:4bcf1d5f4eefecaa325a34ecf079b2741189e7d0821523f92cb343a389a67489", size = 1242416, upload-time = "2026-10-17T00:03:51.521Z" }, + { url = "https://files.pythonhosted.org/packages/60/c2/98370845a7f35cb8a25782e78284b48e01bf3128339881d48d613f304f8f/ast_serialize-0.13.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1b158f1c9e3a0d386913924c57995d6df78224868a4d0f215bdd41587c97b34a", size = 1229729, upload-time = "2026-10-17T00:03:52.825Z" }, + { url = "https://files.pythonhosted.org/packages/d8/8b/2d7ffed76addd9d3fcf37fb171400942735c8912264c763561a85407f6a8/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77a6201b69ce42e919f2fd9a559138d5410b5d8afff7c3a6b1f500b0481ff7d8", size = 1292255, upload-time = "2026-10-17T00:03:54.148Z" }, + { url = "https://files.pythonhosted.org/packages/6b/2a/bb9e0e719d89cc950fadfcfcc9cb4bc7640419c4228c852f031ab8abf440/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6eb0be64c9b8f1ed26637eef345abe75ea90351c92c85a8aec7838b3af971011", size = 1298501, upload-time = "2026-10-17T00:03:55.559Z" }, + { url = "https://files.pythonhosted.org/packages/7a/32/13ce07dce48226f5bd9cfd8f708ec101a8be05aa430cda4918ce31ce8c82/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7f2427bddfca208e84de700044fadf9aef2769a70bae740a1bdabb89ee9e1117", size = 1553758, upload-time = "2026-10-17T00:03:56.952Z" }, + { url = "https://files.pythonhosted.org/packages/e2/fb/9b51d186db0c20ca28cbaaefd50f03b573c89327b9a2627820cbce22196b/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88df960e67184a71874e5b2ee014f87d1254a0dbc1f903c7bd7b1ab7733ecaef", size = 1318258, upload-time = "2026-10-17T00:03:58.418Z" }, + { url = "https://files.pythonhosted.org/packages/c5/fa/da311559dd3dae9af5825cf21660775a929b970f72e3786af3f2cd667944/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f99786e0d62082a5b121b3437f3167562133711df22128de1e9886f57f0b226", size = 1313260, upload-time = "2026-10-17T00:04:00.194Z" }, + { url = "https://files.pythonhosted.org/packages/2b/11/97a4b9e5b4776d72f47fcd9a09a497bbf68ec8c1ae074307a2c51e410d85/ast_serialize-0.13.1-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:a01b515b25a03184eff4acef25b981ae007916379682e908fc8785b342a0bf3e", size = 1309992, upload-time = "2026-10-17T00:04:01.575Z" }, + { url = "https://files.pythonhosted.org/packages/2e/c4/62f85121a80cd451ef04f550cf0f7ea0ad9ff46cc4e9a5b9ae439b6527b1/ast_serialize-0.13.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:29422d7bcd9e7f39411571c36cec45ce8a7a9b3ad4b2e7aa64497c15a9e397f6", size = 1362715, upload-time = "2026-10-17T00:04:02.881Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fa/c5f4a545f72a7681e3295bab6e3600ee0862ec4391bed961fe9f735b67e0/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6ffb0f548a7dc126067fdfb7b2325ab5dfcdeecc29faf5e0f0461c96d6ebfa3d", size = 1469931, upload-time = "2026-10-17T00:04:04.181Z" }, + { url = "https://files.pythonhosted.org/packages/38/a9/65aed4f8fa7a001a7cfdc03e68e844517ab041ba6fb614b7d78a1d6ac056/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:2876444a5f87a7c76f371af3c07c2fda563a08bc8af52568df812e8aba4bf568", size = 1570945, upload-time = "2026-10-17T00:04:05.778Z" }, + { url = "https://files.pythonhosted.org/packages/fb/8c/44b2da991cede79bfbf52089f33a5f0168945466b3d9cd38b5dcf08e7130/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:885a62ec6481ce58ab24c6357360d7a82023b62dd7e5e7ceccf59e9662a3272b", size = 1569978, upload-time = "2026-10-17T00:04:07.347Z" }, + { url = "https://files.pythonhosted.org/packages/46/e4/109b2a5beca700237767d5add920c2f8e1ba9bd5799b0faf143d0e9cf4ef/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:2015fd0165e463aac3b1aadc6a1fa1e5820c14ca950821f4fe02f8a3f6a388d6", size = 1676082, upload-time = "2026-10-17T00:04:08.7Z" }, + { url = "https://files.pythonhosted.org/packages/73/e0/7df70f6dbb11b5762da5416318f08316a1c51348e0d69ec79ca5f98f836a/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:eb41e1906502ac80d24ff343f45008552a3f5b5158607959fe6a07dbfc6eb037", size = 1483207, upload-time = "2026-10-17T00:04:10.162Z" }, + { url = "https://files.pythonhosted.org/packages/1f/bc/523aa1c08bd69b5654621beb3dc1a9035715a4a63762fb8d219d6fb3eb81/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ca9acc67f796aa2554fa3037dccc022a4b08b38b2ad153edfac9c9bb7cb1f3c6", size = 1512140, upload-time = "2026-10-17T00:04:11.589Z" }, + { url = "https://files.pythonhosted.org/packages/66/83/6607060659998f00afdea0d8375c1e6e2b7d515ab905090d9a5a02f48851/ast_serialize-0.13.1-cp39-abi3-win32.whl", hash = "sha256:4f98da562e5901d69c7dd30885594c5438f859edf354e9ac7517d188fb026c3a", size = 1131889, upload-time = "2026-10-17T00:04:12.953Z" }, + { url = "https://files.pythonhosted.org/packages/9f/6f/bafd6490fe7b355627fabe95f4417e3d02da93102c8552550eb9a0774e1e/ast_serialize-0.13.1-cp39-abi3-win_amd64.whl", hash = "sha256:ddf7cbc9c8abf70102c4a088efe154bb86bfb825b0a10e556d2b15972cf99bd7", size = 1171153, upload-time = "2026-10-17T00:04:14.362Z" }, + { url = "https://files.pythonhosted.org/packages/11/25/4235f4b375a67a37ac595bf478a5407a744eaf7b64113c1c3a5432b8d954/ast_serialize-0.13.1-cp39-abi3-win_arm64.whl", hash = "sha256:48f11d96c9ec71119612f8e79a8c55c12f2b136716d68347433c561d27a25f43", size = 1139035, upload-time = "2026-10-17T00:04:15.767Z" }, +] + +[[package]] +name = "backports-tarfile" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406, upload-time = "2024-05-28T17:01:54.731Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" }, +] + +[[package]] +name = "build" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "os_name == 'nt'" }, + { name = "packaging" }, + { name = "pyproject-hooks" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/67/4898a44ea4f3f8e213b0954ec0aa0a16971d62a6212d6ea3931e97115b99/build-1.6.1.tar.gz", hash = "sha256:51cc11666391ab6f092070437ac747002ff46f3e4113a3622177ee6b488bfc53", size = 113427, upload-time = "2026-09-10T07:56:00.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/9b/9fb3585dabcd73a1b2a6267f63f62649347c9e6d072c9fde365b105abb2c/build-1.6.1-py3-none-any.whl", hash = "sha256:ecd351a4be9d35a9eaaba244a7687143c9c7d4aea6ac964e7e7ddab20cbcf4e7", size = 31179, upload-time = "2026-09-10T07:55:59.148Z" }, +] + +[[package]] +name = "certifi" +version = "2026.10.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" }, + { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" }, + { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" }, + { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, +] + +[[package]] +name = "cfgv" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/1c/f41d4e74c28ab327ff3acd36053f7ea506c55872d7a90b0fa71aa3ab0c89/charset_normalizer-3.5.2.tar.gz", hash = "sha256:39de2a259fc954455c57274dc94c79d5842774e1247a016aff30bc0efed0f4ef", size = 172659, upload-time = "2026-09-30T04:39:23.398Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/67/6a0b94a7960d5e1b5eacd2fb529f3fccc47db4644f7f0a7cfdcfc3be578a/charset_normalizer-3.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3d21b8b13c7592db2ac5e544a6d83187b995257472b0c9e8351b6d507ae37ed6", size = 370642, upload-time = "2026-09-30T04:35:06.91Z" }, + { url = "https://files.pythonhosted.org/packages/fb/94/01009e13b94041599004edf32e56e382c24e570f60f79bab8efe45cfe1eb/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d760fe2a4d7c3b226cb9026d6a842868d52a7901bd98420e1baf14e80da85cf5", size = 259280, upload-time = "2026-09-30T04:35:08.448Z" }, + { url = "https://files.pythonhosted.org/packages/66/85/3b5358f60a13210f0b67d3755c168ef758701b021e655d88d4da28554467/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c9790464842f85f437dbbb54417eda1e0e6bfc52dd8d22d6fd1c994b73b2dc74", size = 245335, upload-time = "2026-09-30T04:35:10.104Z" }, + { url = "https://files.pythonhosted.org/packages/74/75/77c1c479b09ecd751d1e767b251ea5c14d4d50ff757bf404afab2692f600/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4685902cf26edf013ed7a3da0f426ebba7a00ebb9541386d835afbf002c11cab", size = 291707, upload-time = "2026-09-30T04:35:11.575Z" }, + { url = "https://files.pythonhosted.org/packages/0b/0d/363f78cacb70f58f15f4b083961bbd9d292f335d3f5c66fc4f1cfe69cb90/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4495c5002a7b28557e7e222e77e0b661183e432b7d6d2e788101e3f240e05b8c", size = 286747, upload-time = "2026-09-30T04:35:13.022Z" }, + { url = "https://files.pythonhosted.org/packages/e4/ed/cf505d3011ffceb12c2067a7a5d3cfe92b875d4d44bb0ff0d69375e2c184/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:211d5a3eb6af8f513b8d4ca19a8c1b7accab1b5f0d3175f9826b03c1a920dc1f", size = 269972, upload-time = "2026-09-30T04:35:14.606Z" }, + { url = "https://files.pythonhosted.org/packages/15/d8/f0a93a431d170e7ca681d4f6650fee3de934d18560e474e7267eb4b0f987/charset_normalizer-3.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ef4fcbf3327382cd4c9f540babd61248208af7b93eec4de397b4d5f58a09e288", size = 269339, upload-time = "2026-09-30T04:35:16.087Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/9b2bd1c5b7af02462c9752d33994834ff972a96b4c483eefde9e594488e2/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd16aabe4a02a297c23417aa17ac6299dbd8c49f673bcd645b4929b11f5a4400", size = 261683, upload-time = "2026-09-30T04:35:17.488Z" }, + { url = "https://files.pythonhosted.org/packages/76/a5/cac540ab0fd61f3fec88ad3dbb64509e71424593d73cfdfff5ab3e4db279/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:fb9e68df06293761f9fe66ade60a9bc6d0f5e42b8acf2939a9158af86ab0e5bd", size = 248143, upload-time = "2026-09-30T04:35:18.849Z" }, + { url = "https://files.pythonhosted.org/packages/71/7a/ff467301deef2089fad87f72df9e000a26a78fec7acbb18e1999371b8369/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:59f63901b0031c3136cf64704dcb21de0bbae62ce2c9529bc39d27665463de37", size = 292358, upload-time = "2026-09-30T04:35:20.326Z" }, + { url = "https://files.pythonhosted.org/packages/ad/77/22d7e785d1e210afc2e2f58600dd1799d17a35665faf84383f002826c5f8/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:304d5463e65a35d7bb0850550e0780395395f6fcf452f04db7d5ca7cecc425ac", size = 268766, upload-time = "2026-09-30T04:35:21.72Z" }, + { url = "https://files.pythonhosted.org/packages/ae/91/e8e946267f1c2d9e2bd651726e2fbd2addf02c4d36cea5069e32ca9d7bb5/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9cf9b1a857e25c4baceeb3624e92a56df3668f398c4acba74e174d81fb4d1d3a", size = 287432, upload-time = "2026-09-30T04:35:23.273Z" }, + { url = "https://files.pythonhosted.org/packages/4e/88/7561d8a88d555e7df6623abe7c0070b4baf47549b9408783a2ae0a1a6cf7/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:114e4d0c92d618409ed82a99e22b5c5e768fe995f2973f78265f4524f49d4640", size = 272470, upload-time = "2026-09-30T04:35:24.655Z" }, + { url = "https://files.pythonhosted.org/packages/35/7e/578c702301ec036f01455f30744a08d2b42f6ab35b9b2d4bf8cae0ef2a80/charset_normalizer-3.5.2-cp311-cp311-win32.whl", hash = "sha256:2625388c6c754520c37abaf3b41eb34d1cc4a373f457898f08606c8e362b891d", size = 186688, upload-time = "2026-09-30T04:35:26.225Z" }, + { url = "https://files.pythonhosted.org/packages/e8/fc/fdf8cf52ff21cd5bf158f20978991cf985325842f74283eb6df26c8a39d8/charset_normalizer-3.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:87e50a3e7cb90af586b6c5faf23e302a970415ac73bd7bd90a515a04b427ef96", size = 214932, upload-time = "2026-09-30T04:35:27.796Z" }, + { url = "https://files.pythonhosted.org/packages/97/66/3e45a506d8110b632541faf9a9470185aa9878f1ed44020f31346c1c5e5b/charset_normalizer-3.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:254eb48b9fa5ee9898a3c445825a1f340fe53712a098904b39b0bddba8ea3cb1", size = 202828, upload-time = "2026-09-30T04:35:29.259Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c8/693809898870237d82785a03f3b2b58fe4c9f14669f84a7d4e623c92a59e/charset_normalizer-3.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed2a239c0ea213acc1908150a3037257083c7c083128f1a4cec2ec4b97dca491", size = 367780, upload-time = "2026-09-30T04:35:30.888Z" }, + { url = "https://files.pythonhosted.org/packages/c9/87/2fea8c13dc24b3ca9c6f803a5b2dfdeae73eb4f9e12c7885ed908ff0433c/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b91363207bd9dc966a691e959bb47f64b30f7ac4b072be9968b366982f7db77c", size = 246730, upload-time = "2026-09-30T04:35:32.286Z" }, + { url = "https://files.pythonhosted.org/packages/a8/9e/09efac30b937722f46d3110ba30b875b24b2e3a266ed746cc4e376a94d80/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:38a873987f3be698494da8b2e3085e29da02da7b633dce73e79c699a113d7bf0", size = 237707, upload-time = "2026-09-30T04:35:33.709Z" }, + { url = "https://files.pythonhosted.org/packages/9e/18/70d76670b13686237863a379928d60bd10e021f17d243ab3d7014c4a5f4e/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:355ad8011081dec5412240c087a9a0c9d4d5039f3ed11a3f13e18c2b29b56c51", size = 273050, upload-time = "2026-09-30T04:35:35.138Z" }, + { url = "https://files.pythonhosted.org/packages/54/e2/77a8b09d5adc013ed07b95b01b8b8fa5441c4e810e83ee7e4aae2fa4d91a/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ee21e28f0430bd6dc9086c6e525d5e818a44a5ad19720c8a0ef766792f3eb5e5", size = 270345, upload-time = "2026-09-30T04:35:36.502Z" }, + { url = "https://files.pythonhosted.org/packages/7f/c5/38806a25ab5e65fc178f39affeda20858efafede2fce1ffc2556cfc9fe73/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d31298449090ab8d47b7b1b2a555ff73cac7ed438a08b7ac160980c7ebed649", size = 257601, upload-time = "2026-09-30T04:35:37.919Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8d/213565184708fdb263ae55e2c04ee1ff748129dd65d48ed0e3502da9c85a/charset_normalizer-3.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5cde776b7cc66e4f6c99612cea4aa7269aa65863f7a15841b2c264f103822f4e", size = 252222, upload-time = "2026-09-30T04:35:39.544Z" }, + { url = "https://files.pythonhosted.org/packages/7e/24/76d2cefc25472531e4c5c7dfff68865eb1c39b78482f0fdc15b46f047830/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae4f5fea5b8b8ccff88238cc8569303e5ee95efae67fa62922a311397a71f346", size = 248482, upload-time = "2026-09-30T04:35:41.088Z" }, + { url = "https://files.pythonhosted.org/packages/7d/dc/65a801b66ab4c197e22c433ab25e7ac24324ac6f45a2269aca42cce309bf/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f7d486c83842422badd511868fd8a9a20e9407ace71564b6af47ce7e60a336c1", size = 241206, upload-time = "2026-09-30T04:35:42.59Z" }, + { url = "https://files.pythonhosted.org/packages/a7/95/ca9b5eabde673002c6f1e7ada1b223916fe18f6d661da7aabd4d643718f1/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:11a4d68a6ecda3292cb1e50239e111543ba5d709bb62a6b4ea1afcfa729d8875", size = 273190, upload-time = "2026-09-30T04:35:44.347Z" }, + { url = "https://files.pythonhosted.org/packages/2d/8b/803b4d2a3f6e1740f63f1e87b04d14b42f3d4fdfe6ed7d4db2d34102b14f/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d6734d2ef8a50fbf8445c139477da401f50d62a0606bf00e20ec6d87773fefb1", size = 253527, upload-time = "2026-09-30T04:35:45.915Z" }, + { url = "https://files.pythonhosted.org/packages/a9/55/93c0e5dbd085ae0471346026abbe7e0db9ea2d6fea74e51f0b5a46f233a7/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a815775b6c38d4e0ff7bcffbeba67feded90202bb6a226b8dd35f1c855217413", size = 271285, upload-time = "2026-09-30T04:35:47.49Z" }, + { url = "https://files.pythonhosted.org/packages/95/69/0dbd0e0b9b16cfa816cdfcb3e2e3854a1f680dc07fb1245ea125e7448060/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:23851fb4e1b85ed3f6c2a27b777cdfe2e19fb5b38429a8faf38c7542b7665869", size = 260010, upload-time = "2026-09-30T04:35:48.996Z" }, + { url = "https://files.pythonhosted.org/packages/58/9d/e7b88e7b1bf403590c3b573277b5e1e488c68c7a6fbacca310a2c324e90c/charset_normalizer-3.5.2-cp312-cp312-win32.whl", hash = "sha256:db19d07e2e0129e974a0e65d0064fc222a446cd5122c2fd4184d2af9fc734a9e", size = 184125, upload-time = "2026-09-30T04:35:50.777Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e6/e6e083884cbcfd49c64865af05027fe7011be7b2d9179524f099a1b611f3/charset_normalizer-3.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:780fbe7cab297b81dad9fb8dc5eb003c0468ffb0d9e5f65068c53a34661a96bc", size = 207486, upload-time = "2026-09-30T04:35:52.194Z" }, + { url = "https://files.pythonhosted.org/packages/c4/e3/017aea0911ada7405a825c7d937eb3a13009664e2f5b38e8c4bbf2abf894/charset_normalizer-3.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:e2af3aad578aa6bd1384bcf4750fc285e5a9de53f40b7d41e5a0bf748edeb2b3", size = 196734, upload-time = "2026-09-30T04:35:53.636Z" }, + { url = "https://files.pythonhosted.org/packages/c5/34/68292d68512768591aaff07c59bb53ee31341c87759433a859c4641a50c2/charset_normalizer-3.5.2-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:ed905975ab14056a2e5eb1c376cb2e1ebc5396baf84163939c518556fccde9f5", size = 225946, upload-time = "2026-09-30T04:35:55.313Z" }, + { url = "https://files.pythonhosted.org/packages/e3/80/bee0b01b90ccd5322ae1d0abb33fab1bd95b7c2eadaf02aeccf22e04ee83/charset_normalizer-3.5.2-cp313-cp313-android_24_x86_64.whl", hash = "sha256:a66c3bc5ab1f0ff2164fc9965ddd611ff0802173f4b9d24554c563f6ab7e1d6e", size = 238619, upload-time = "2026-09-30T04:35:56.863Z" }, + { url = "https://files.pythonhosted.org/packages/78/6e/60ce52a85a7fd631ae8482ae6d74521014ca2f255892679484dc04d7ef56/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2374b62878abb00cd8309b32af6c0b715cd02dec0ca74ef12e5069bdc64144a", size = 206701, upload-time = "2026-09-30T04:35:58.639Z" }, + { url = "https://files.pythonhosted.org/packages/36/8c/71aafad23f971afc84c2b295bc0c560739ce1dac558aad9fec22e39f3639/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d376bbd28b3a8999db1a103b3b388aee6f1ddeb3e51bc2172993efdcd86e064d", size = 210506, upload-time = "2026-09-30T04:36:00.147Z" }, + { url = "https://files.pythonhosted.org/packages/91/da/3c5a7798c046df7d2d68ad653cf5b6c5a8bfee225055a843c6f2f42aac1a/charset_normalizer-3.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6045373d5a89a5ec71afde535db987ca28e76dfa276c2d4c818265b375d4b055", size = 366626, upload-time = "2026-09-30T04:36:01.77Z" }, + { url = "https://files.pythonhosted.org/packages/e1/16/710ac3de2ee354e2bd1a9c94efe45a2d27b5c6ad39b2d6a905be2c094b6c/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:849df64e889b2e17230d58410a03dba311a65b163508fd33679b2b737d4b7858", size = 244624, upload-time = "2026-09-30T04:36:03.389Z" }, + { url = "https://files.pythonhosted.org/packages/d6/39/45c7439f5b63d24f7d5b2a1d760f34af7628782d7144b4cc8ded45c2d4bc/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15c44f7edfd477b06f517a5cc317fc1707edb9de2c865f43d4b6513907473234", size = 235731, upload-time = "2026-09-30T04:36:04.987Z" }, + { url = "https://files.pythonhosted.org/packages/4d/34/38f3154785ce92e9f56eb226f4d35bdfae6b008480dd055f58837a89c810/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a89012d6d5476ee112d20d998570ed58df2260a852afb1758809cd6900411d21", size = 270352, upload-time = "2026-09-30T04:36:06.412Z" }, + { url = "https://files.pythonhosted.org/packages/04/f3/859f74e7babc977705026b30593b3be04049632a522fb7000f83c033d747/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0c951d5e6dd9c2ff60609476752bee49da4206adde960ebc247766937f72e718", size = 267393, upload-time = "2026-09-30T04:36:07.865Z" }, + { url = "https://files.pythonhosted.org/packages/4b/85/41d27f234b82e47c167a5f6c0f62501dc0c640585ff4aba79e08a390336a/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7218e8f32b0956cfcd048fd42d9d5779809745ca1d86113ca56f66e7ae1549c4", size = 254660, upload-time = "2026-09-30T04:36:09.248Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/5d1a997587febe5b26d8daffe363b5c1a091cece19828eec6502fd09c5ef/charset_normalizer-3.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19a731138fc27d5682277d3b9df22855cea1239bce7fcec5f78f42ef2d1f3c3", size = 249996, upload-time = "2026-09-30T04:36:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1f/d1e78246f7ed60c8c8d606b4ac27f66ce49cc3e95f24893ccbeba9f77302/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:62603db9a7caa0802eaa28c1c46fecd7b3a263a774069c24c3c28c302448721c", size = 247028, upload-time = "2026-09-30T04:36:12.294Z" }, + { url = "https://files.pythonhosted.org/packages/8e/37/eba316edd4f0c4d3a5d945924c4eeeae59abac4056aa815d8a4268f863a2/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b6856554c4f44d79fc2307d5768854310a8f0096e501c75637542c82292b0429", size = 240562, upload-time = "2026-09-30T04:36:13.887Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8e/aaa037d40ca9ef045977f1a661048b1aa33f223adfce3452fe9be9f79d14/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1bc0baf5ef96b6ede57d47f4b8fe4d9d84019c3bfcbeb20a41edc6a6ee341f1f", size = 271699, upload-time = "2026-09-30T04:36:15.41Z" }, + { url = "https://files.pythonhosted.org/packages/26/19/1c1c9f75974adf523b87f34b8a2adc5a435cd65916812bcbd0dfa45f9a29/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:56bc200a365efb37383b7852e4cc5898d3b2da5987289b543956cf8cad71018a", size = 252030, upload-time = "2026-09-30T04:36:16.839Z" }, + { url = "https://files.pythonhosted.org/packages/bc/90/0660ef18e18df0a4d2a1a0edff7dfbba42d4e50ef2425557a5bb7051f77b/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2c9ad19a6cfcd5ea5c0d41161d22f9df1dcc277e9bef2751391334546a314c00", size = 268565, upload-time = "2026-09-30T04:36:18.468Z" }, + { url = "https://files.pythonhosted.org/packages/79/ba/57adc269824e8658f1a0f97a9e514c247445a9632b3419b97e0ba37f16dc/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e243bd13217235fc7290c621941c3f5cc8b66e4872495be821d7436ba2fb838d", size = 257627, upload-time = "2026-09-30T04:36:19.938Z" }, + { url = "https://files.pythonhosted.org/packages/9a/85/33abd4315c052d3d4f54c92b1ee49bfbc0dc7115a981e462a793b6d2ab87/charset_normalizer-3.5.2-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:a090bb2c68df85450502e3e20d665e3a5af9c65a84d6508ed477badd49166fd3", size = 143407, upload-time = "2026-09-30T04:36:21.376Z" }, + { url = "https://files.pythonhosted.org/packages/4f/de/6435e18d1aaa5d910b896d551411c96af1f42a0c56c29afc2016c61ccc2e/charset_normalizer-3.5.2-cp313-cp313-win32.whl", hash = "sha256:2b7b3bbfb4fe8ef40600792d762fbaa9057559f9d3fad209525b7a22b99e91fd", size = 183207, upload-time = "2026-09-30T04:36:22.776Z" }, + { url = "https://files.pythonhosted.org/packages/9c/76/b8ec57f4e9ee3253541abf95e4a462c0175fe8032dcd070f1f2421240942/charset_normalizer-3.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:78456a747de8dc58360ffa581f30a002baf5aa28cb262536545e91f113ed7639", size = 206489, upload-time = "2026-09-30T04:36:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/3e/60/c647c6ae47480221e875ea5d743ff94946f7416e3c69415ab772928e8d32/charset_normalizer-3.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:11912e4bb14baae7c5d8791aa55ba0a3a03ec6729073307b0f57270abaa713d3", size = 195501, upload-time = "2026-09-30T04:36:25.846Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/7aa91362a2f77ac8e9e28a9b902a74f7d0e11a851ef0d27a74308da8cd90/charset_normalizer-3.5.2-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:1afb975bd5d68d5ce9f6b6d44fdf2f7e34b895a35e95708a7a91b20a3b51d187", size = 226010, upload-time = "2026-09-30T04:36:27.669Z" }, + { url = "https://files.pythonhosted.org/packages/a8/cf/ac8878d0322cf88a1aad4c7b147db32ca0bd806eb0060957b2e31486dbe6/charset_normalizer-3.5.2-cp314-cp314-android_24_x86_64.whl", hash = "sha256:bbbfc8e28816f19d7c0f1816664980c0a9875d01b27cdf8eedddb639d9e108ad", size = 239266, upload-time = "2026-09-30T04:36:29.434Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6d/9a08d7e0b29b7208e2c6c01dc56c8e0520e7c7beadbbfb024b58fd69c8a5/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7967d08cf06dee78443b874f98c98036f624f3a4e73e11f9f64f5be4d25393cf", size = 206783, upload-time = "2026-09-30T04:36:30.872Z" }, + { url = "https://files.pythonhosted.org/packages/82/44/b0aa350280e6ff5a5492d17cf10460dd39d5ee848f872f7ba2df10607f60/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c2b5031f63e331e3839b40aed2dd6f191e9c07edbde303e7876846ea1946995", size = 210449, upload-time = "2026-09-30T04:36:32.625Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8a/40db9aa9f5907bb0e6f8b6d64064bf8852fb33d4b813ff9414911df7647c/charset_normalizer-3.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fcff63213e8e6e47770541a4607175404f47cbb3ebea7b6058cc82d524a0e424", size = 367815, upload-time = "2026-09-30T04:36:34.197Z" }, + { url = "https://files.pythonhosted.org/packages/7f/72/9c5e7707b57c8ddfa9ddf7b0b1d009d7fbab9e9e887d5b721060f37e307d/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d86d6fc60743dc916eb79e2eb1ec4818e21e427731543af40a3021851174a13", size = 247095, upload-time = "2026-09-30T04:36:35.803Z" }, + { url = "https://files.pythonhosted.org/packages/83/09/71e453691e927de4ddf792770cfaab3f49d494e222f66ea5e404bbd5e39c/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a881931aa470808df94a8c380eed2bbbc76cd9dc622310f99665658c821eb6d", size = 233942, upload-time = "2026-09-30T04:36:37.407Z" }, + { url = "https://files.pythonhosted.org/packages/9f/86/85c84e4da8b27dd409577d9437926ff581c5f9d3c66038dc68c1a526de51/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8024d00c3faf3fc0c16e07a69f4405e8eac7cc0ab15f65fe6cf43827c4cf72b4", size = 273762, upload-time = "2026-09-30T04:36:38.904Z" }, + { url = "https://files.pythonhosted.org/packages/92/08/564955a4b5f2ccb410ab480bbe8c6a18063ff27f2d35458731c4a5335df9/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4d48f2d08b9de5864e2c8744d4461b862fb149a18274abc8b698c45975573438", size = 269514, upload-time = "2026-09-30T04:36:40.469Z" }, + { url = "https://files.pythonhosted.org/packages/18/24/bad3ac4271589df29cf5ce2f5ae490518a5739358052bd0d61209e6fea54/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34276fd796040bf0993ab33a369aa572e6979c7aab225a88893667ad8eac8f7a", size = 255056, upload-time = "2026-09-30T04:36:42.02Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3e/350d89ad49916b86554d6f5f2d03ec1152148f87e5ff735106c6a03b1a36/charset_normalizer-3.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0521c5665880b33d603717defa76c094048900010897909952397feb3039da56", size = 251311, upload-time = "2026-09-30T04:36:43.577Z" }, + { url = "https://files.pythonhosted.org/packages/56/5b/4970a2d154df502e133402906dd04e3ae7cada7b3011283c88d0479a2585/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:eff0ac9dbe711a4aee69bf04a83896aa9b85f19641264053a9f6d48573abb7dd", size = 250190, upload-time = "2026-09-30T04:36:45.185Z" }, + { url = "https://files.pythonhosted.org/packages/88/8c/f1a91bddc8fb47c2889e29ea7ea49a194eb0d9868675d786806519c00d76/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1503bccbeb36d5527790c3930327704c39af22de3112f1b1666a9f3ce15ee204", size = 237098, upload-time = "2026-09-30T04:36:46.689Z" }, + { url = "https://files.pythonhosted.org/packages/24/0e/bb5dace3cc7e79068425386a6589c19b5a2ab5fefc2a46abea6919683332/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:52aa6992700996af31f375de0c6bacd402b0097fe40b53c426b9f51a90ebabc7", size = 274228, upload-time = "2026-09-30T04:36:48.31Z" }, + { url = "https://files.pythonhosted.org/packages/9d/79/b849ad523017ea9f5a45581bbebed91439e0cf42fd2860a6f64e358eb5a6/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e09a3942ecbdee5cce73ea9d42da82b81b72ac1bf031ce069b93b5adf4eac8cd", size = 252401, upload-time = "2026-09-30T04:36:50.091Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/75469d690cf47200bce8f6cad7655724fc23148e147abfc5ce78b5f65863/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c7c9ab723cde841fefb34efbad91e87f00a674b1fe1cd0784fde742bf2c154dc", size = 271846, upload-time = "2026-09-30T04:36:51.719Z" }, + { url = "https://files.pythonhosted.org/packages/26/cd/6d52d3c7437cdcf2e310ce9f28f282e733d4ef60ed19105d1819c356255f/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ddc7dacc8ece3a182e7f15cb862d1fd616b46d076cb1ae9dd232b2c38b655874", size = 258151, upload-time = "2026-09-30T04:36:53.234Z" }, + { url = "https://files.pythonhosted.org/packages/f7/4c/070b38bdb5f49a70199fce923ec0726a49536a63ab262abbfcaaf351110b/charset_normalizer-3.5.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:ee43c17b173d46a3212baa6ead3ae258eeabdae48c263a01ccf0218c366dd655", size = 143570, upload-time = "2026-09-30T04:36:54.816Z" }, + { url = "https://files.pythonhosted.org/packages/81/84/9ebfc8ed6c8c4fcd8e726ff6bf220cc8deb3966e31dce9be8dd8aa017e64/charset_normalizer-3.5.2-cp314-cp314-win32.whl", hash = "sha256:4f87960d57feabfb618e4e0af6e7371645fa26a277860739d6e5d6e0012c92f0", size = 186412, upload-time = "2026-09-30T04:36:56.643Z" }, + { url = "https://files.pythonhosted.org/packages/d1/78/5ed86f743d4bc350db307e7636419a0a5ee1d91806d30c7f667bd5c80dae/charset_normalizer-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:e4e81e09c1578b8df602e3db08b0b3ea0a6947ad612f52bf8dc5ea8d47691f0c", size = 210965, upload-time = "2026-09-30T04:36:58.205Z" }, + { url = "https://files.pythonhosted.org/packages/53/94/a3a7698e9b1a395e1eb99ccd9a324be9347973bff4e72db2a06496d7cd27/charset_normalizer-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:80d02b6f04e92601a081dd97b23d3128033098bff5d35d392ddcc0476ea11253", size = 200406, upload-time = "2026-09-30T04:36:59.764Z" }, + { url = "https://files.pythonhosted.org/packages/c1/48/c5dd00d5ef7791f02666de250a5bb6071e29b7e133cf4b835800b6d3bc27/charset_normalizer-3.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:dca9ab98072a5a54ebacebdc45f53e645336b320c667410b061be1ca588ae709", size = 396871, upload-time = "2026-09-30T04:37:01.543Z" }, + { url = "https://files.pythonhosted.org/packages/12/c8/8379554b42e8368161d898476686947a0fdbd3e8865170d7909dcabfdee8/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0aa869112ef88429ae17820d99c3dd9504c9e9c671d3c246f3d7442cb051084", size = 249711, upload-time = "2026-09-30T04:37:03.111Z" }, + { url = "https://files.pythonhosted.org/packages/4a/eb/2ddb1035d17320caa9f41682935123a9a250277b261c3efc86b2d2a21343/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c0afc6800ba57ccc350374c5bd6150419915d95ce93cdbab2d783d75eaf30ecb", size = 231146, upload-time = "2026-09-30T04:37:04.721Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/2ecb4bde104322cd7859d6594fcfa74649f8d90b3221c9feecbef149875b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7dcd882da75ef9adf94903b1e3b9419e8aa8fb4c7396822b834b9ef7fb96954f", size = 271552, upload-time = "2026-09-30T04:37:06.295Z" }, + { url = "https://files.pythonhosted.org/packages/3f/98/9d5f6ebc3aee9fef5d30b4aff11fb2ab7a1222b4064f8ef2c7c87cde217a/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e06a3a98f916dd41d27f3105e02e7a40181c98c94b9158733d03a6f80506c09", size = 269810, upload-time = "2026-09-30T04:37:07.905Z" }, + { url = "https://files.pythonhosted.org/packages/09/e1/a3b06a10461b1b7628853c934c644e03bc28e42767116afb52f19a56519b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bd128f206a7752ae1f2ab6c61bf8a24ba28913a10df8b14c2637b973ff97a80", size = 259845, upload-time = "2026-09-30T04:37:09.554Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d3/6f561f74a296cf27d61775a1dc665ad13f3bff6a798810ca05907f37a7c4/charset_normalizer-3.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c8f3d67aeaf55f017982b73683f0e7342ba2f6635a78f69ce89ebb26aa411e5c", size = 252825, upload-time = "2026-09-30T04:37:11.274Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/69e13ca3b18f43e0eafcd34c04a45b732ae22a43b54a5fc9e119103356eb/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fe9753dfee015c570d73df76f899f18444d41388bffcde097deba51c4fadbb9f", size = 252659, upload-time = "2026-09-30T04:37:12.941Z" }, + { url = "https://files.pythonhosted.org/packages/73/a9/ace29806a0dae18939919c76ba526472d83214afa101105fabff2cf30625/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:92888bb3187c5ba50500b00b3b310c9f2c651709d28036077680cb5255450a03", size = 238819, upload-time = "2026-09-30T04:37:14.659Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c1/6116d52a2e3311ec80f21f5fb5e17b27405f10b9608af8f6e69516841a1b/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d008d90a7f2471519aef0c90dfbe73b3e6e4d5e66ac48e19154c17e89e98b604", size = 272973, upload-time = "2026-09-30T04:37:16.346Z" }, + { url = "https://files.pythonhosted.org/packages/19/aa/9955c7e93bba10a9c7e8f7a5031b7ced66f3a1883a55c00712b8d5850ff3/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31f3930700408d211f13378ccbe1c40845d8da54bd0681fac3a9b5aae81c7aa8", size = 253692, upload-time = "2026-09-30T04:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/bb/33/2a6ae7fdc1b10cb581cef91addd8cdfc5f40d50abb5702309369d5834579/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2a925889534b3748302dae5dead07cc13480de1dac3aea80a941b729b471ef93", size = 268757, upload-time = "2026-09-30T04:37:19.877Z" }, + { url = "https://files.pythonhosted.org/packages/a2/22/80992720a0282cd39bba1db35868e6b9c22f41281160143a836544bc1d8a/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f5ec61164adcec446f8969a3358ec3f9b26bbda3b9213e5586d219afa8df2915", size = 262220, upload-time = "2026-09-30T04:37:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/92/9f/181fd07e1bffea1d95cd80c84ac537354f50699c22cfc4d3c02b6fc16208/charset_normalizer-3.5.2-cp314-cp314t-win32.whl", hash = "sha256:598a11a2c7ebaa5334bf698bf29568c9c390abac6a154d8170fedecd1cea38c5", size = 197797, upload-time = "2026-09-30T04:37:23.235Z" }, + { url = "https://files.pythonhosted.org/packages/49/1c/25d8415ec1c4f2f41f1680435e4c87cfb378ff2f677d950946f2a45d0632/charset_normalizer-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:7fdde2c9fd9e3eca40631e024664cf2584272cc8f96308cbe5fdfc930f51d8bc", size = 222765, upload-time = "2026-09-30T04:37:24.891Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b4/46b48f013dadfc0d0d33b375438e31bdf5a989dc68389c6bf627054d4df9/charset_normalizer-3.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d1befeed746d247c81127bb14de9dc3d30edb6e5976d34f83f86ed262b1d9105", size = 210985, upload-time = "2026-09-30T04:37:26.634Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e9/34e597dee616d0b8ee4b34d29399e85c2204ade174157a48505d42baa4ff/charset_normalizer-3.5.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:87475fabc8d9996fd9c27debb395e642e8c838d78a00b6e932227a0e06b81e26", size = 367676, upload-time = "2026-09-30T04:37:28.329Z" }, + { url = "https://files.pythonhosted.org/packages/60/9f/a5d1c91c0263745e2cd344c5a4415d787c575501ab1d449f1148ac6b495d/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9409a8bf35cf78353942504b24a57de3d75b708997a1e4bd8db71ac8633ce364", size = 248414, upload-time = "2026-09-30T04:37:30.167Z" }, + { url = "https://files.pythonhosted.org/packages/26/79/e697f77464748a3ee3cf490c83d592459400d4898380d66c38366b03080c/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:498dc3188ca05a68231ac3fdbfc7f57eb67e1343c30e0fea17f8218c1599b253", size = 244775, upload-time = "2026-09-30T04:37:31.964Z" }, + { url = "https://files.pythonhosted.org/packages/ca/87/3d42a42e18ea066e2513936fd678a00696e77878b5ae04528976abdbcb83/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e242bb1c5e76e97dfa9e7f209a71e93a01d7f19ffdd5cfbb2e2d55b4f08f8ab0", size = 273877, upload-time = "2026-09-30T04:37:33.661Z" }, + { url = "https://files.pythonhosted.org/packages/c3/76/8a28136f3938ba9836f84280ce0c4d61ed1cf15a036b2034900c62634162/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def79fa35ef0cef8d2accec024f4fdc7ead3012ff02f5215c783f39f03ef8cfc", size = 269455, upload-time = "2026-09-30T04:37:35.573Z" }, + { url = "https://files.pythonhosted.org/packages/a0/a1/4fbf5d0f0f1b2a080474c1cf9a2f12c4c6531bb0e8ba591055e846d2b4e9/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df041de8887954562c9b261cba85ca0e9ded74048daf125f45edcfaa4832229", size = 257336, upload-time = "2026-09-30T04:37:37.397Z" }, + { url = "https://files.pythonhosted.org/packages/ba/a2/8b50aa320adb880ad579518e6f718f24944804b42a88b83d267d5d444125/charset_normalizer-3.5.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04851f73ae72b8413dddadb16a49dfee95263553741fd42d546f7d66907e6be5", size = 257584, upload-time = "2026-09-30T04:37:39.522Z" }, + { url = "https://files.pythonhosted.org/packages/a5/57/50e3fed84e175f40349bd0da7a4fce94c87f0378f52d74f511d89e0bdc20/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:183b88127acdb4fabe59d951ab424faf1af7b63cdbb5f776186c1ea2ffcaed98", size = 251854, upload-time = "2026-09-30T04:37:41.23Z" }, + { url = "https://files.pythonhosted.org/packages/d6/54/f7fbb3493c9f49091213b9c2d6dd65800696f1ce1a3f196a4205f50417b1/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:16fa0eccf81304b79c5cd87f9271c3b85dd9dd99245e4422ae9c0dd45e0f99d3", size = 248767, upload-time = "2026-09-30T04:37:42.883Z" }, + { url = "https://files.pythonhosted.org/packages/d9/37/b3a6385acc5a1e45b39ae9c90bfb9cf838a09b9dd37ef2740ab4c6b4a2eb/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:7441d755b7ab94f8d4eb3e43ec05482d760842fd263d003a99102d742cd835e2", size = 274479, upload-time = "2026-09-30T04:37:44.658Z" }, + { url = "https://files.pythonhosted.org/packages/89/44/809913e2cfd279e635a9294fdbbfb1b1dc62a8189d473d561f649fce98d8/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:ca403d7e4798f525fdfc78e258820419cbbd0f0ecbab9de7840e3c017cf6b8cf", size = 258310, upload-time = "2026-09-30T04:37:46.529Z" }, + { url = "https://files.pythonhosted.org/packages/af/a2/f28400ab13359d91bd39179df8e149376b9bf36588e739a3a4f9de2b84b2/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:df29a0a7107f7011e77f4eebdddec4c7331e24d787a0b21a46d63bdf7445da95", size = 271100, upload-time = "2026-09-30T04:37:48.399Z" }, + { url = "https://files.pythonhosted.org/packages/e9/89/9bab37955edf0adb3b66f8a3a6617d9f2f487e0d56f295a6a286cb640aa6/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f3c96f633825733f735c5a9cf21d21a257d8e1edf0b1cee0a064b9c424ca0f7d", size = 259936, upload-time = "2026-09-30T04:37:50.023Z" }, + { url = "https://files.pythonhosted.org/packages/23/b5/4459e08d45a679f903d50fea08bc52cfa728cca4d7bd02c757b5e5abda2e/charset_normalizer-3.5.2-cp315-cp315-win32.whl", hash = "sha256:281cb91036248400f4cc957495cccd44c275c2e0c5854f7e45ac5cf7dc193847", size = 186301, upload-time = "2026-09-30T04:37:51.722Z" }, + { url = "https://files.pythonhosted.org/packages/98/e8/55d5fd3935b4bce6da4fe0df61898e8c82653e317e677bd58aceb9c60f13/charset_normalizer-3.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:89b53f3cda69831909888e0494f4fa0bcd3537e3e138dabeb620bd6ad946bae8", size = 210858, upload-time = "2026-09-30T04:37:53.427Z" }, + { url = "https://files.pythonhosted.org/packages/a9/5b/974423c2fd8e524c7a7f64318c1e02240ef954912fa2b4d70344107b9c68/charset_normalizer-3.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:6be488a102b8cf28d0391d8c4ba7748938ae28b78ad901f8585520fca33ead1a", size = 200309, upload-time = "2026-09-30T04:37:55.015Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f9/00ee0195db1013d8f7c416fd770fbeb560bb46eb2e36b054d05cb56f6cfa/charset_normalizer-3.5.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:915563965d418f986e7e145accc592eae9e1a1be3566ff98a05d7a9ec42a76e1", size = 395343, upload-time = "2026-09-30T04:37:56.743Z" }, + { url = "https://files.pythonhosted.org/packages/04/3a/c00b50e94c964cf934c7899cd47c97952fc11dad71cc5884b3c61795b09b/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65cd72beeeca9d3aaea1201e5923859f308f952f9c71de93f06063c79f0f7a3b", size = 250114, upload-time = "2026-09-30T04:37:58.607Z" }, + { url = "https://files.pythonhosted.org/packages/50/27/d102dc880bbcffd0479ab64dfc1fb96777a854355a55e2bda72a71efadcb/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b7fd005a73d9e657273b7a10dc71a9e03c8fb9ee6999798d6918ce095b81ac7f", size = 239997, upload-time = "2026-09-30T04:38:00.511Z" }, + { url = "https://files.pythonhosted.org/packages/a5/4a/bf7ef45794dd293fab5f98a9309817977fbb845b9998f171b8cc5d8437a3/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e54da4baf05720032d527874d40b65fa4d7e5c6c6a43d0c3adbeffcaf275a2b3", size = 272313, upload-time = "2026-09-30T04:38:02.509Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ee/008a2837737991474c5754bb3191010007663860979701990982a502cbaf/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:124fbf1a8ff966d87ae05bb8bd45a71f966055ed8bba320d0c7cf450bc5f4d0e", size = 269986, upload-time = "2026-09-30T04:38:04.435Z" }, + { url = "https://files.pythonhosted.org/packages/93/ad/bd74a283940dc910c5b14f8e4f80a248082bc9c0fcbe1f54530cb6d9cc5e/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28b4f0d66fb834ff90f28209ac7bce77868c45d8c93e26f906709d9b7c2e1af9", size = 260202, upload-time = "2026-09-30T04:38:06.549Z" }, + { url = "https://files.pythonhosted.org/packages/8a/7b/ed341c66f69f688723501fac752be3d63c7159ca0d0d4174fc611e5710bb/charset_normalizer-3.5.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:58ca3755ee7ff7f59b57789ec9833c9de9ea275405cdd240eda1f193112e398a", size = 259083, upload-time = "2026-09-30T04:38:08.311Z" }, + { url = "https://files.pythonhosted.org/packages/cc/9d/e41588b777965e5031a43128a1e96173ebb35ac75fc53ec3b517e7c21cd4/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:443eae2bf318abeaf6f15d785138f71fd6de770e99a92158b8b814265e079115", size = 253081, upload-time = "2026-09-30T04:38:10.402Z" }, + { url = "https://files.pythonhosted.org/packages/81/35/b761eb6d8c1eb218b9b42b9b4d5ac902afdc399fb6dac6f9a9aac7bda589/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:58f361dcbab699cf8f42db3f47c8e7fd1036f138c23a5d08de9fde5f425a730c", size = 248712, upload-time = "2026-09-30T04:38:12.317Z" }, + { url = "https://files.pythonhosted.org/packages/4d/2c/147169a041b747759f37405c0a97157e8e92de967968373101ff14915cba/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1b4cbc7c3491ccb4aa17fcd8165649d01cf39f76de1696da8631b5f71b85401d", size = 274176, upload-time = "2026-09-30T04:38:14.138Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2d/0ff8db0d373ba8538db686db11cd7e8912031490b9e4f383b41912e8d594/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:ba0b1d2620edf869789c3879223f52bf2afc5d31b3cb47cc57b3a12c05e2aa9d", size = 259413, upload-time = "2026-09-30T04:38:15.841Z" }, + { url = "https://files.pythonhosted.org/packages/8a/8e/b4a085fb47c9d3a7e43576a4784fdd8fe23f907514a972de8086edaf7a48/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:5e2b6b57e9733d39f0c9fd3185efa6b8e29652c4cd8fe94180272cf6ed9a78c4", size = 269434, upload-time = "2026-09-30T04:38:17.626Z" }, + { url = "https://files.pythonhosted.org/packages/83/1c/d8d8d7322a7c3eecdf3237a4a419cf41d2eaad8e006ce7dfdd9d4c8fa2eb/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:51cf45226a9b588d0d2b4880c62d686934b63ab0bd79ca23ab0e9762eb27441b", size = 262716, upload-time = "2026-09-30T04:38:19.214Z" }, + { url = "https://files.pythonhosted.org/packages/a0/16/0e4c6ba9b44e97a2da150e52d331e8f9c968b21b358fbffa6c856cebcd89/charset_normalizer-3.5.2-cp315-cp315t-win32.whl", hash = "sha256:5fb29fb8cd1a46c27a1bf9613ad5ec2599310d46b4025d9556404a6b6a292800", size = 197159, upload-time = "2026-09-30T04:38:21.037Z" }, + { url = "https://files.pythonhosted.org/packages/be/33/e90bc2b1374f7f36ef106f56620de5a783907e19ca857efe2277e31cac3e/charset_normalizer-3.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:a192e2c40070d92c3ccf777e3a5c4ff515573cd2bb7ed0c537fdadbbec5bbf21", size = 221322, upload-time = "2026-09-30T04:38:22.886Z" }, + { url = "https://files.pythonhosted.org/packages/66/89/dfa6dcb08c200b7830ab56439e8c1890f2971d51aafbb3937894a2e7fcfc/charset_normalizer-3.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:749e97e1b32313717a565abbe321bc2190bc8b35f1a67e4cdbc7c56c8d8ffe58", size = 209192, upload-time = "2026-09-30T04:38:24.648Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ab/176fbfd5b64939c55d652366aa5b9ef1d767af207a3aa6ebeb0d226c484d/charset_normalizer-3.5.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:4275811936e2f06feff5e598fb42a1b7ae852da8e39605211892b56b81a34efd", size = 331815, upload-time = "2026-09-30T04:38:26.216Z" }, + { url = "https://files.pythonhosted.org/packages/7e/84/371eac6b30bdbcbf2d632a1a01809103459216fcaae61b8b8d922c1bfb8a/charset_normalizer-3.5.2-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1c50fe28bbc2ced33386f298650d91218076c05420e6cbd790b913adc41659e7", size = 253276, upload-time = "2026-09-30T04:38:28.032Z" }, + { url = "https://files.pythonhosted.org/packages/43/6f/c4fbae58febff71709c51bc7e18fdfa55341dc382704740f9f0cbf03817b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d19fbd981a488e22cd04883659ca6b08f50b5974f9fd7c95655ef6a043e5893f", size = 241239, upload-time = "2026-09-30T04:38:29.732Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/458c3f42164a07d0c5210798e9e704b39e540a6793b05aba67f3a35243a9/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0fed1d06615f022ee3b13caf5e8b180cfea32bb2c5aded8a9d44277afc040f93", size = 231121, upload-time = "2026-09-30T04:38:31.462Z" }, + { url = "https://files.pythonhosted.org/packages/09/54/ab9e89367076f6331bb6c65c4bf14a5361fa5191cb6561bf534f18504e1b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:838dcc90063569a0448120554591a1d6c4a4ffe11babf048908793154ab86ade", size = 260350, upload-time = "2026-09-30T04:38:33.239Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/061431ecc688d9d76602502cb57cc01e691e682c18f1beb45f9673b5bbd2/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2ce45c6627b22c47e390bc91a41c3d13032192e699fa0bea96e9671b373d69b0", size = 255430, upload-time = "2026-09-30T04:38:34.865Z" }, + { url = "https://files.pythonhosted.org/packages/8d/1f/20c8949f0676f7ab811abdeb7f4d7f1cbc6e61ff20bef08b44edeb092bc8/charset_normalizer-3.5.2-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0774bf9bf620249fee3e0b8b9fd3065de213be30f3aa94ce2494b3b638949e26", size = 250612, upload-time = "2026-09-30T04:38:36.649Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9e/46f2fa4c431fc98c4ae76a8cb5bdca54e0341e3cfc3fcfd8e82740250818/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1db38f4c5496827c1a501846d64d14c3b80c7e6714e406cd7dc36a9899fa1011", size = 242083, upload-time = "2026-09-30T04:38:38.26Z" }, + { url = "https://files.pythonhosted.org/packages/bd/39/559be29a0c0f086e0bba6922babd38916cc5e0b58ced4de13ee01ea05508/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:304d8e4d493af723536393eee0c689eb7813f4a474c8b479dee63f1fdd98f621", size = 232738, upload-time = "2026-09-30T04:38:39.81Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6c/387b0e4f756a282831c1d9fc6aeb6c51ca4507ca202767c8de15ce9b12e2/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:9b7f416ff0978e2f2249330527f0ad6fa02f4932e6199692d3b52da2048c19e4", size = 260703, upload-time = "2026-09-30T04:38:41.346Z" }, + { url = "https://files.pythonhosted.org/packages/96/92/1fdf015f09ef449f50d3ac4b67c90887c9c318b727daa95cc4f866e6521d/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:01077390b03f7988f11d700a2194e69b119741a86b1a638b1db88891e3eced8e", size = 247622, upload-time = "2026-09-30T04:38:42.937Z" }, + { url = "https://files.pythonhosted.org/packages/dc/3c/8e7b8a5671ad5d433669fb2a76f1a0164df2d9b1718b0206bc2a16d840cc/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:7e841fb9010836c992c9f12fcbd43a831de93a5f726fc1ccd8ca1d0268c5014c", size = 257500, upload-time = "2026-09-30T04:38:44.604Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f0/45b579df5cabc1d5d53ea1cc35e8437d3ca768c0acccc7041517cb6fbb32/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9cae88599c7219005d879f98e5ed53341e9a122af585e1091200358a3003d2a0", size = 255100, upload-time = "2026-09-30T04:38:46.289Z" }, + { url = "https://files.pythonhosted.org/packages/31/68/fdec18a343f5fb3f310588dd478b09ac4799e0b187dbade3a8cd776f03ef/charset_normalizer-3.5.2-cp37-abi3-win32.whl", hash = "sha256:01b0c0d2262a9e28e8484a278c7e1b5d650e3ac8cf2683d2967e25899f208bdf", size = 174499, upload-time = "2026-09-30T04:38:47.999Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8a/b618149cc5207943a0242068d7a27897f56a62947b5a039085f2a22029f8/charset_normalizer-3.5.2-cp37-abi3-win_amd64.whl", hash = "sha256:9f56f72050826f63dcee7a7f55b0a77168cb3bfc553fd405e7f8f9ece75a4036", size = 200092, upload-time = "2026-09-30T04:38:49.707Z" }, + { url = "https://files.pythonhosted.org/packages/03/cf/4c66866fa9e2b1c78e3c911516d1de497a677b7ac60f1eceda74ce777ca3/charset_normalizer-3.5.2-cp37-abi3-win_arm64.whl", hash = "sha256:40ab6bffa02ae10a0581e6c198be7d2d8ca5c2a0c64e4ed3465d766df457573e", size = 294363, upload-time = "2026-09-30T04:38:51.312Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/d07d7862a62ffa6d79d68074d14823243dd235a77c45262acbf6adeb28bf/charset_normalizer-3.5.2-py3-none-any.whl", hash = "sha256:b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685", size = 68872, upload-time = "2026-09-30T04:39:21.828Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "coverage" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/9b/639ff6f5b3158999fab6f03cb7597526ad57e15cad0c6cfa9b64bac874dc/coverage-7.17.1.tar.gz", hash = "sha256:5c5c77f95a0e83e6b79eff948d251c9911cfd61d67f5059159fc25b7bc4aec27", size = 995565, upload-time = "2026-11-03T12:38:47.608Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/28/bc914aa69f2dd27cfcebedc62acf472fca357389ba80295a8fa693d6ea59/coverage-7.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e7429e44cf754fec4baf895307d7b3b906140df82f5c8637777e9cf4227afd87", size = 227529, upload-time = "2026-11-03T12:36:03.283Z" }, + { url = "https://files.pythonhosted.org/packages/97/46/60f46d3219278e53455a4fdb4b755e7c47a0be5b14b89f2c827bf28bc8eb/coverage-7.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:08d773b49e0001ef360a4ee7cf8e7a2101a52007fcc5b46ef56ad1032bd403b7", size = 227947, upload-time = "2026-11-03T12:36:06.739Z" }, + { url = "https://files.pythonhosted.org/packages/27/18/791ca5cf2f4b38c1e3e421d80992a67be4f0c09b5add22ff1e3c164899ea/coverage-7.17.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fa52a8600a7cd6f219b41254bb6a04e000da4a79bb993d3c5b21a625f93425f8", size = 259977, upload-time = "2026-11-03T12:36:08.067Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ed/952fea2330a020cd2bb4315aee09d75716c20f2920d0c3b952e7bf28c992/coverage-7.17.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c33792ae97208a5a978ac63b16e70d344946ed1a0db3abb1ea64f1f7b110b5b5", size = 262198, upload-time = "2026-11-03T12:36:09.452Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e6/761f6eefeee17b634b104004214cccd08b0350295ad5d0fd8bec447c5224/coverage-7.17.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23a49c5949e96b5eae1cf16aa3f37ab6fbcf1a15602cdab9c7c31cf2ebd49307", size = 264294, upload-time = "2026-11-03T12:36:10.725Z" }, + { url = "https://files.pythonhosted.org/packages/ae/dc/4ebdbb17f038dc1e1b8677514af2e832705085327dbe4ca5760914aad83a/coverage-7.17.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:adc720c43f820c91e3b89158ab6b6d162532fd925b0d06ad32baf2bdf130f41c", size = 266304, upload-time = "2026-11-03T12:36:12.32Z" }, + { url = "https://files.pythonhosted.org/packages/8f/34/7597613c900c361370d2a8a7345939072aa8c751fe54dc374ee55fed0bb4/coverage-7.17.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f96ac45a2adb46bc59c2c2c3dc4303501397a906a7ed953832d2f03712a82774", size = 260091, upload-time = "2026-11-03T12:36:13.759Z" }, + { url = "https://files.pythonhosted.org/packages/3d/36/b6b0dc241df22b3f61ef2fd26675fc14309bc3642a6f9c9d9cfb5f689383/coverage-7.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f75d95a0fbbfa4095c307027e9a9286063f12c4f4b9f5df46023f9011175b32e", size = 261993, upload-time = "2026-11-03T12:36:15.072Z" }, + { url = "https://files.pythonhosted.org/packages/f6/c9/c8d973fe07fd67378d49a45085c7fde6f2da5a01329541fb26cc83afd0a1/coverage-7.17.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:06ee57242ba8b5da8a38289f4d70c767529e089c5e5f5492dec1851e3c0981a2", size = 260006, upload-time = "2026-11-03T12:36:16.487Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b0/1f321be70939ffc74ede6b1387f5b727397870cb867382873fa6b23c047d/coverage-7.17.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:eb3e0fa955355da7cca2b4b55d93a4c59b60862e5563f9fac506e35e245cd302", size = 263932, upload-time = "2026-11-03T12:36:17.855Z" }, + { url = "https://files.pythonhosted.org/packages/a7/d5/5cd76e78fceab21289e344768660638b2373aebb4155c6fa76007a2e25b9/coverage-7.17.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2dbdfb11dd06d10829e13724b4858e61925bbb16c5b396f7d9ccc250bcee916d", size = 259534, upload-time = "2026-11-03T12:36:19.331Z" }, + { url = "https://files.pythonhosted.org/packages/e9/52/265f3b4eef6b51f7cb5ac12f356e186388861530719437b29a8d76f5c218/coverage-7.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:23faef6b1b30335aff610b70f4203ae19b19deb6abd637fa9736f01da4d5588c", size = 260733, upload-time = "2026-11-03T12:36:20.643Z" }, + { url = "https://files.pythonhosted.org/packages/92/b9/fe77b52f2ded65934e0d9a559ca8385400fd54401988004dfe4242af9606/coverage-7.17.1-cp311-cp311-win32.whl", hash = "sha256:110ecef18899cbe49d7a904bb45e3c5f13a7d9c2114ba39daa9a0f3ca9eaf41b", size = 229397, upload-time = "2026-11-03T12:36:22.021Z" }, + { url = "https://files.pythonhosted.org/packages/57/f6/6b856eba8d5bcdb521c9cc41b4c4edf88a4ac61aa04e0e463f67b38872ee/coverage-7.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:c4935efed225aa96f39b5ed7db08baa96996efa85c5a9d3ae2bde3ff8487631b", size = 230001, upload-time = "2026-11-03T12:36:23.372Z" }, + { url = "https://files.pythonhosted.org/packages/77/d8/11cd7ebb5b80f5570705a10f9f3ddd11e6a0b8ff9d6580f46707145dd458/coverage-7.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:6c7182c03dcea5e457553f38ee0005dda781bc26c734d10659365775d5a02fe7", size = 229910, upload-time = "2026-11-03T12:36:24.679Z" }, + { url = "https://files.pythonhosted.org/packages/64/37/0e501535cfd4c71555ac26fc951cd926d6200f20ba5146cb34de429f5e36/coverage-7.17.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7ae17b0127df7298fffec6866d45969620ca70267cf8961c5102a872abfd0198", size = 227626, upload-time = "2026-11-03T12:36:26.151Z" }, + { url = "https://files.pythonhosted.org/packages/84/f8/619e48ba82da0ff2fea7e377e427d5a1d4e918dd90613240145576aa76c9/coverage-7.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b8a8f0b1d662828e7cfd52ba6d4e8d79496d4711057c33daaf29f50414d5f8c6", size = 227859, upload-time = "2026-11-03T12:36:27.659Z" }, + { url = "https://files.pythonhosted.org/packages/45/9c/93a83fdb0120538192d38b0fe77deb6036eae357a803a1e62b9bb7d1cf57/coverage-7.17.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:710a02c4a2f7de5f08c2ecd26fced31099032b8c3fcf2f602e4cef5190008baf", size = 260153, upload-time = "2026-11-03T12:36:29.012Z" }, + { url = "https://files.pythonhosted.org/packages/35/be/2704ac4e51ef9075255314cf547e44f43cd4bde96c9efb7da826ce39ce57/coverage-7.17.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:622f0d4869db8fdfa3a7ee2c6b0207b17abe59b462617599c8c3def27f482d78", size = 263480, upload-time = "2026-11-03T12:36:30.308Z" }, + { url = "https://files.pythonhosted.org/packages/ef/83/64edd51a572196239890825cdfefce0c38f634de439d3d840bbe33e09271/coverage-7.17.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d8ba77c22882009f4f6599ccc88a9170b9c6e69f4464c2ef235e9ca24b62f68", size = 264016, upload-time = "2026-11-03T12:36:31.667Z" }, + { url = "https://files.pythonhosted.org/packages/71/95/c9998e7e718e86f85142a0cbf517d100ba2bb4c068f814245f96a253772c/coverage-7.17.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ff5288d8b03519e05697cc7065e75c55a10ce4d7581108978b549516c7edaab", size = 266294, upload-time = "2026-11-03T12:36:33.03Z" }, + { url = "https://files.pythonhosted.org/packages/46/b0/73c6276d5c75239b725207e60b19ed23a4d8c564a92232890d7ba9e70bef/coverage-7.17.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6c461a379dbacd1b92c3800f529025e3b85a41a90b97e49d3b004ec690a13847", size = 260386, upload-time = "2026-11-03T12:36:34.463Z" }, + { url = "https://files.pythonhosted.org/packages/3b/57/9374f6513341d07c1a02bdbd37ee7e98fbc8d963da9e71dc4b580ef86994/coverage-7.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bf29880edc2dbe589f3bc9fc7ea9a4c81cdce118a69feb52bf4dc420b475ed9b", size = 261901, upload-time = "2026-11-03T12:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/ea/ca/50a4fab6983deb19d0ef8941c64e69e09d9428523c16e38262a0a28d379e/coverage-7.17.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d416449f86fa1af6a9c1031fbd27ad7c1d30f57945bb52cd28250266c46ae549", size = 260066, upload-time = "2026-11-03T12:36:37.426Z" }, + { url = "https://files.pythonhosted.org/packages/66/db/4c5e12596e68084a59a108712f2a89e5cedf30fc3f2fd8b2b38e62d300a5/coverage-7.17.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a7858779514aa04242f7fd7b4a92dd395d08fe791ba33624187d6c68f96245c6", size = 264114, upload-time = "2026-11-03T12:36:38.937Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9b/2c8bc32551e15080c894d7f7d8c13589c91980923a11a96b51ca7c538eee/coverage-7.17.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:b367f16bf32939fafa8f26669fdb59ab21ee601527ad716aab7cd178ed3bd28f", size = 259566, upload-time = "2026-11-03T12:36:40.514Z" }, + { url = "https://files.pythonhosted.org/packages/f3/54/9cbf5e95496e2f8d8684eea3e7f1f4911375d01c73ccb51b067385c0d77c/coverage-7.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a20b2945e275fe76ed2ed6be6103aa4d8e923b8f2678f1f3dc31c6ec8849c8a1", size = 262053, upload-time = "2026-11-03T12:36:41.975Z" }, + { url = "https://files.pythonhosted.org/packages/d1/3e/ef5728364207026031aac8f068e68f15bf71c1a84046efbca4623617cd2a/coverage-7.17.1-cp312-cp312-win32.whl", hash = "sha256:6c89aa3497bd593e1bfd9f57ebdecc5544387b5e94e6d4c6cb7597565eb551e6", size = 229457, upload-time = "2026-11-03T12:36:43.227Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a9/8830de67aa3b16f94e6cc456dde07db95d0ea8001cf8224340cdb6d47cb4/coverage-7.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:6e6c9759a42cf946ca427dbbd772305516401ff6d280b93cc52e7b11fcedfb2a", size = 230037, upload-time = "2026-11-03T12:36:44.547Z" }, + { url = "https://files.pythonhosted.org/packages/6b/00/a932037e8a27705d8f1aded46edf879d8f2592392dcd025349fa72d9b5a8/coverage-7.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:1c06c40a9fb03ab43ace3ee27a11e61ebf233161fb9ebabfb2b51f78cf1602e0", size = 229843, upload-time = "2026-11-03T12:36:45.821Z" }, + { url = "https://files.pythonhosted.org/packages/04/e0/ff26f5a74cfcfe131bebe09649a9c9dc84a8fe8fed5cbed0117c57f7efeb/coverage-7.17.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:9b8d68b2330cda90e1972e78c93c6fd572453c5b4e29594aa98550694efb0466", size = 228775, upload-time = "2026-11-03T12:36:47.054Z" }, + { url = "https://files.pythonhosted.org/packages/df/af/b83c4a7d7ed81458298c137aeefbfb7a088d36fff6fb60a0f8375e731990/coverage-7.17.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:b975d0bd867eefeff37ba28aee6ee08a0987ca3ce6bfb5e0d3ddc1b40cf3e52e", size = 228845, upload-time = "2026-11-03T12:36:48.362Z" }, + { url = "https://files.pythonhosted.org/packages/52/07/3156d72bb538d05aa4cf51d90a86cc705e9cb570d8a0eeef80880cb21d09/coverage-7.17.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:60002a0ea7f5e5f64006aba9f37aa29a4b1e52756bc0fbbc2471188b2732e4ed", size = 227091, upload-time = "2026-11-03T12:36:49.687Z" }, + { url = "https://files.pythonhosted.org/packages/cb/50/03128c382b303e02a48b1f9658bda6412288fa1d83b478696a08e410c0f6/coverage-7.17.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:80b613bd68caa146d090023a18dfc504eb958ff525e31e6f2368b363502bb1ea", size = 227396, upload-time = "2026-11-03T12:36:51.162Z" }, + { url = "https://files.pythonhosted.org/packages/90/83/b617213e11609d6d5d64afc701e40384bbfb39c9999531ef747b6d1259cb/coverage-7.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8c2e67f95c8de089ba0ff11c7b7ee83ec0890d418e8d0185e863367f5250a087", size = 227516, upload-time = "2026-11-03T12:36:52.897Z" }, + { url = "https://files.pythonhosted.org/packages/44/98/71e36bd7bc121a33c5c78a1f687587802b2806299feb4b9f2fcf21616007/coverage-7.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56f81ec13a8790a0f2ea30a14d2f39dec2374115eb88cb25cc2c0226f72f8b0e", size = 227781, upload-time = "2026-11-03T12:36:54.144Z" }, + { url = "https://files.pythonhosted.org/packages/04/e8/28f4c350e124242a757b86cd19d71d807eda8b202126c39fb57eb1495f7b/coverage-7.17.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b7fb16b5c4fa1a37d69204ec5f7b8b187d2cfc54a2c084e2750ceee443748ac0", size = 258947, upload-time = "2026-11-03T12:36:55.461Z" }, + { url = "https://files.pythonhosted.org/packages/64/94/f99d4cbd1b187ac1029cadf293a934f8a2300908d8055b5c9de11577a875/coverage-7.17.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b05c06318fd46706c9055a1acc6f4aa0d3a63b211bf3b6114d3c1feab76e37f2", size = 261858, upload-time = "2026-11-03T12:36:56.804Z" }, + { url = "https://files.pythonhosted.org/packages/58/9c/b91da5d4790ac926e6bede81a1bac0b8e216d2574f5c332c7494d23b88de/coverage-7.17.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f3bbb5f9c074e97f7082987ead736036aa522cb39b996b8ed9c5aa8eee008be", size = 262791, upload-time = "2026-11-03T12:36:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/4b/15/2527c7e46bcc7f69e792b7a0eba1e70d9effb5ae29f29d704487954975ba/coverage-7.17.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6eb807f5eb02f64eb19f39b63015de046b312b847e3919b639a0ca19ae9a10eb", size = 264857, upload-time = "2026-11-03T12:36:59.79Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/6cf7a9cc1a4188227dc74e9293dd006e6e76b97e24747452f3b17b300f30/coverage-7.17.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0bf74f2960a3d0f39067bddd658db1331a17828c93102922864699401df82dc7", size = 258994, upload-time = "2026-11-03T12:37:01.07Z" }, + { url = "https://files.pythonhosted.org/packages/98/0d/1f027bbe75df8b9553e87ad49889a288409e25bad00032391678b612c5ab/coverage-7.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3da4fe4cd099239c10691ff6deb9fd291e5438ad77c2583cf235a5b9aa9250ae", size = 260950, upload-time = "2026-11-03T12:37:02.553Z" }, + { url = "https://files.pythonhosted.org/packages/a4/25/5f02f89f262a126a90fda3061ea5beb0721202d9b8469b4a50adb85b2e2a/coverage-7.17.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d2c2973dcbcd883ec94305f513b7c05be6359679f25ad7134adf0cc512cf405e", size = 258871, upload-time = "2026-11-03T12:37:03.896Z" }, + { url = "https://files.pythonhosted.org/packages/50/2e/61f046a3ecddb2fc6e44350de857840e01fffbe83246302aa2382e8b9ac5/coverage-7.17.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:deea769f5199ea3e8053d5274e737e84f4a9cfbb1e69330066101825b098aac6", size = 262967, upload-time = "2026-11-03T12:37:05.191Z" }, + { url = "https://files.pythonhosted.org/packages/33/41/a45075de5bb61a646882912b7fc21cd594a83fe9be0ee6c77ffafa3a2ba7/coverage-7.17.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:7fdea302c956e1e85526a294ce64495b0029edc451b4655e2a9a85af6029fa24", size = 258721, upload-time = "2026-11-03T12:37:06.44Z" }, + { url = "https://files.pythonhosted.org/packages/89/ac/a58424f93baf37f1f36a9ad60d622d84482e26b017157e101ad87e965e28/coverage-7.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:32141eb9f9d228da33d45baf789736bc3c00a31ea9150aa7f48bbc08cfe2849f", size = 260799, upload-time = "2026-11-03T12:37:08.058Z" }, + { url = "https://files.pythonhosted.org/packages/27/10/9c424a67004ebeff99a03030115c4f8562eefabf0fa2ae889289efa85aa9/coverage-7.17.1-cp313-cp313-win32.whl", hash = "sha256:fc7b1ee12d7376ea85f6d09a272da3011c879e605d2f354d4a1c21c890cb571c", size = 229400, upload-time = "2026-11-03T12:37:09.337Z" }, + { url = "https://files.pythonhosted.org/packages/9e/0c/1b92a40cf24fa09e1bc2e7f9120a312e0b4a792b5f907852cbf64b75ab98/coverage-7.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:26d0fa82cd76c888058c182b8ebb6326578f89f01cc1e576dde76bba8e446261", size = 230128, upload-time = "2026-11-03T12:37:10.69Z" }, + { url = "https://files.pythonhosted.org/packages/c3/af/67fa4bc27bdd15514810ac43c1f1285ca46e9b7af29859655948574f419a/coverage-7.17.1-cp313-cp313-win_arm64.whl", hash = "sha256:ddaca2c745275aede7b7511618aba9e1e17728f772edd1d2016529def73df01d", size = 229853, upload-time = "2026-11-03T12:37:12.173Z" }, + { url = "https://files.pythonhosted.org/packages/80/3b/41fb1e5297e4a14ec9a4f8d620b7c5bc4acd62ad8247a84287c5f05a3611/coverage-7.17.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:932a542ea396dc842d0d2882ac95f33242c0029ddc226323c243d7e35978bfde", size = 228890, upload-time = "2026-11-03T12:37:13.495Z" }, + { url = "https://files.pythonhosted.org/packages/80/a0/e7b12a2e40f9af75ed4e64cbf7a9bfd17b9e1834bebd4e46b5965cb0be06/coverage-7.17.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:6cd9deae02bf24bf16fd72d1c505e81beb4cd0bbfc1b75af8ba1096a8461e62f", size = 229006, upload-time = "2026-11-03T12:37:14.729Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d7/3b69b6d1fdaeb399c6a0f0dee5b94b337f5248c0d0d5b78d736563d7eda6/coverage-7.17.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d1d62732067fe938796db0b460b0788db69cef8f91e802747eb59b2d4c1da9f9", size = 227174, upload-time = "2026-11-03T12:37:16.022Z" }, + { url = "https://files.pythonhosted.org/packages/1f/5a/a7fa52b9a98b98fbbeecc18abbd0bdacb292c4121a31497b39f54146a0d1/coverage-7.17.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:7681bd8f1eb33c778fff244bd06dacabf1e4325fa578c8265367216ac8b5a059", size = 227475, upload-time = "2026-11-03T12:37:17.356Z" }, + { url = "https://files.pythonhosted.org/packages/12/d3/394272eadeb616010db92d4d650b983c54b0596be87685c242b9e1f35b1f/coverage-7.17.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4c948f185d1ca81ee2f1383f1a51387277bf6da5b14a469136031827d51d0ced", size = 227712, upload-time = "2026-11-03T12:37:19.062Z" }, + { url = "https://files.pythonhosted.org/packages/3a/5a/35108cca71cb81b671492aede98a422330bca2558aa07d2cf3ee249ff06e/coverage-7.17.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9db719b76551607ca01b5b5464f554bec78344fff4a7f09c58f4d55cf9499cd7", size = 227866, upload-time = "2026-11-03T12:37:20.408Z" }, + { url = "https://files.pythonhosted.org/packages/5d/56/21400d3216320c3214bcd88b6d57e7217a4475d37494cfc05b2c2984b6f0/coverage-7.17.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:612b22d9322a0728bc209122847fd48d6353eea92e314f70a1278350dcd48de3", size = 259786, upload-time = "2026-11-03T12:37:21.688Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/a8ab57e646da306d854613bbf2972a8a20257fecb5edb13ca2378774af9b/coverage-7.17.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:22edba362121a928bb4bff377915e5ce9b8f2e254239f93f38931de021485d32", size = 262792, upload-time = "2026-11-03T12:37:23.015Z" }, + { url = "https://files.pythonhosted.org/packages/c1/94/5e40670e4893e8e8cb338ae80f7c43e6cc47ce1f49891a2d02b94184605f/coverage-7.17.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5ee8e36fd04c566fdf3d0e978b343eb1b96e9444484c199a32648cd60b0c2e4", size = 263774, upload-time = "2026-11-03T12:37:24.314Z" }, + { url = "https://files.pythonhosted.org/packages/af/1e/cf67121055a6540e7ad0060dac0d2061bd39ac9bc45fe9168a47c0fa40c9/coverage-7.17.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a87e4286f0743d0e2a0eba077453595afb6cfb2d0d18b25dea74dc9553e8dad", size = 266251, upload-time = "2026-11-03T12:37:25.535Z" }, + { url = "https://files.pythonhosted.org/packages/18/8d/b2884aa3cee232c924393ba0b7db5d44f520e02a56497e176e5128e9a4ef/coverage-7.17.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:806ab974da8a718697a329a126ae3655f0c8d8bfd12a7ca6c2089a2350ed0485", size = 259565, upload-time = "2026-11-03T12:37:26.798Z" }, + { url = "https://files.pythonhosted.org/packages/fc/11/1c0ccea4d6d35ac421d10f2b210bb61f3e412ad769bd5cc08011876c7577/coverage-7.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2cd58acb64ad41f2e01a4d35e35c1060a1dd64699a146caef8c360cf7408083a", size = 261626, upload-time = "2026-11-03T12:37:28.196Z" }, + { url = "https://files.pythonhosted.org/packages/13/1a/ba1b45a8da773e70e5b1cdd08450a5a7cda84ab31a7aeb2c2a8c94361b2b/coverage-7.17.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:354ceff3c2233ed017df0f4d5d65dcd87c350ca6a129fcaa9478a7031957b03c", size = 259668, upload-time = "2026-11-03T12:37:29.526Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ff/5e4ca2c677569f439269a0aab412f8e198751660412b4613ffa3f2473e5f/coverage-7.17.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b927e5e4708344f94011bcb36a58023f82d2f0c8757ff2c5bf869d5c6ca0aa16", size = 263965, upload-time = "2026-11-03T12:37:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/14/28/d0880224c1f8182e523c454aadd30c89af959b477245463decc7bf166cc1/coverage-7.17.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:65ad67be7eb4c9c48814c35c53f5fc1cf6ba17892b0e183ef3413b991085df62", size = 259298, upload-time = "2026-11-03T12:37:32.282Z" }, + { url = "https://files.pythonhosted.org/packages/5a/64/0f7c0ba50b6d3083478be28b0ffdc1de9d16df1d8abfc920de164e8ef60c/coverage-7.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9e85d83d4e41e7ec7fcd026765947ae1b068eb134ba820c8ebb3bba290878972", size = 261408, upload-time = "2026-11-03T12:37:33.999Z" }, + { url = "https://files.pythonhosted.org/packages/92/71/6eab8cd02e941a8473b1e1ed579848e51a3ecaaf8300e1a43d4059d32fa0/coverage-7.17.1-cp314-cp314-win32.whl", hash = "sha256:457ad13b8ec34f5dd607cc9b68c4f6af579dfe1bb6368a25e334976860c03329", size = 229639, upload-time = "2026-11-03T12:37:35.238Z" }, + { url = "https://files.pythonhosted.org/packages/54/42/fb8cedbe674bcdecf37327b014764c98a6bbcbdf2b5faf4ff12ad850555e/coverage-7.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:73a8278e7dcd338e8be66eb66deea97dc290cdc0b50e176bf96095dd498addb3", size = 230271, upload-time = "2026-11-03T12:37:36.738Z" }, + { url = "https://files.pythonhosted.org/packages/08/78/2fc61e1a128f21a6673e3ee5273e494f02489c6f2b818152db534d0c879f/coverage-7.17.1-cp314-cp314-win_arm64.whl", hash = "sha256:3be94c7a728f5bdeb09fe6d0b89542e57e0162a80555a205eec849fc25e45695", size = 230121, upload-time = "2026-11-03T12:37:38.417Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ab/bcbd5e621a8c6e14336fbb0570a2d4268e1259e7ed1f0704701c314608b9/coverage-7.17.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5208b4cbd83fdbf6cce21fb6137e1986c9c5a5eda6400029ab1b448c5b8f9747", size = 228174, upload-time = "2026-11-03T12:37:39.637Z" }, + { url = "https://files.pythonhosted.org/packages/9a/0b/d0307ba45d2f46d1ebfd421e9eb8201bb3bbdc5edd388432e33c3c2f850b/coverage-7.17.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:efb34d2401f0ef64502f46f9f077b376836cb5cdb98b5d481da534487f7d3f15", size = 228551, upload-time = "2026-11-03T12:37:41.044Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b3/d855372f3e102e3ad9f4bdb8fbdd71df501a932b17b8da9dcd14dd2188f3/coverage-7.17.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:70c1747f2c7b146396da314ec0a7e45ac3dc25b883f39fc7e73cbbb42ee02a6a", size = 268543, upload-time = "2026-11-03T12:37:42.233Z" }, + { url = "https://files.pythonhosted.org/packages/5a/2c/c0dffce72ab78176d2fc9d0c695399394b172a8fef880f73670bd9061759/coverage-7.17.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9412b525747a004fb450432aba6b0ed28891c6d224507020f2c1b05787b9c9da", size = 271097, upload-time = "2026-11-03T12:37:43.461Z" }, + { url = "https://files.pythonhosted.org/packages/cb/54/1e810bf8040b335a9a1434aa29ac278027413b0209638674481a7a4439e6/coverage-7.17.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45946d12c25ceb14967e873a0a46526cfe337b075b6dff917603fd4b5448b90a", size = 273718, upload-time = "2026-11-03T12:37:44.734Z" }, + { url = "https://files.pythonhosted.org/packages/0a/5d/c8c8becee8228047577f7b352902fe34a4cca5691be12120caf3faf71d5d/coverage-7.17.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:76e08d61b3791098befa989da61b899ad0e4b36686534cd0078d68e940a97eed", size = 275208, upload-time = "2026-11-03T12:37:46.06Z" }, + { url = "https://files.pythonhosted.org/packages/26/fb/b00edd3abb50265c7165922b1a6820fd4b34d2917f5d573fa19ae32f73dc/coverage-7.17.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c5b025803be4dee29fafc44aa6bc20255842ab26dc27de19cd0e90c4e8bf6ac9", size = 268433, upload-time = "2026-11-03T12:37:47.833Z" }, + { url = "https://files.pythonhosted.org/packages/45/af/42809663d7a98ba6f95dd976527a0b5d762eed87701dab71af4e14e60adb/coverage-7.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:782d2f15f59864202d3939e9bea35b8a6fae6a1d4ef489beca7bacd24058b160", size = 271007, upload-time = "2026-11-03T12:37:49.118Z" }, + { url = "https://files.pythonhosted.org/packages/92/4f/9b93e96f43f8dcc10bba69ac1ade3e707b91581d04847e05f29abf0b0136/coverage-7.17.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b34dac11d9e03897f64732e3cb3a3e8dba29a7f32a34eacb9536591099fc254f", size = 268434, upload-time = "2026-11-03T12:37:50.413Z" }, + { url = "https://files.pythonhosted.org/packages/5b/ee/bc1983e6715cd211c21dc0389d1d32b789f7dfec31988cc67016aa5ed7a9/coverage-7.17.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a01f6f44bd92958dba923aa414d1b868a74d175574adb50d50d60157f85da242", size = 272731, upload-time = "2026-11-03T12:37:51.802Z" }, + { url = "https://files.pythonhosted.org/packages/53/29/7a7be7b0f778d48f13908f1bb8eb0d02f9e09448d3852974cc235effbe0f/coverage-7.17.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:62726d1c435d1476de876bd9c6656cc69d157e0e3c419cceb4a8a588db55017c", size = 267851, upload-time = "2026-11-03T12:37:53.083Z" }, + { url = "https://files.pythonhosted.org/packages/f1/80/9b8e09889158a06d9776551d7765ac2627ae21428189af39d21818a314f3/coverage-7.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:05858414f6c3557c9ce2d4348215997c3834bdb95a9f6f62e97ab558d1960fc5", size = 269785, upload-time = "2026-11-03T12:37:54.396Z" }, + { url = "https://files.pythonhosted.org/packages/1b/d6/975b76074ce079c3a91248b94bab4f938f5fc39970b384cb292d26b3bfa2/coverage-7.17.1-cp314-cp314t-win32.whl", hash = "sha256:04d8ce47c70cc3f8e760cfabac5c3182f3e03829dc3cecfbfca69ff7d7ee48a6", size = 229953, upload-time = "2026-11-03T12:37:55.731Z" }, + { url = "https://files.pythonhosted.org/packages/bb/34/b55e15f3a916bb9111bad357a44413bc123346f4b72ee002f810c2e8eecc/coverage-7.17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:006453b2515ea4c44a857e07b985429038b164080fa777cabea6d22d2e686325", size = 230884, upload-time = "2026-11-03T12:37:56.971Z" }, + { url = "https://files.pythonhosted.org/packages/d1/73/55ce659eb8a4e31c48ff433f4910dc48fb843a672a64f51fc6dd918d00b1/coverage-7.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:b1dc930b405b761efbfef2b3782ae5d12e22708d8086875c5f1e64318b2b857f", size = 230453, upload-time = "2026-11-03T12:37:58.467Z" }, + { url = "https://files.pythonhosted.org/packages/8d/76/a3443e64fd29e8709f274875d56f9d0c399d13d2146ff785865ec8df7766/coverage-7.17.1-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:67e193d7c93aa93870d78594adfbe2926e9ca8bbc92c963c011092441880edb0", size = 228888, upload-time = "2026-11-03T12:37:59.709Z" }, + { url = "https://files.pythonhosted.org/packages/28/37/de21f8bebe25f3bf95f368451db12e884147514139fd0b8bc18990b2a1bb/coverage-7.17.1-cp315-cp315-android_24_x86_64.whl", hash = "sha256:eea6030a00b96f656016ea58b19d61fad3de7add8340e2e7c3b032d1516561d5", size = 229006, upload-time = "2026-11-03T12:38:01.022Z" }, + { url = "https://files.pythonhosted.org/packages/a5/41/fbf7073c3d6b053106352bfd2b4de8e0c9d27756fccc22d6b0ee20a892e9/coverage-7.17.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:603b5795c56fabfe2d0fcd64685eacba5eff1c7797741fa9b898564bb53a9207", size = 227185, upload-time = "2026-11-03T12:38:02.539Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b1/e758d35cf81d6c4f405f66578ed59c1dcfbb1de5deb5662c5bf23057b6e5/coverage-7.17.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:ae938f631ffdf9183851140a245b44f74e35f25fc7d72edb261546ffbe8e5dde", size = 227486, upload-time = "2026-11-03T12:38:03.816Z" }, + { url = "https://files.pythonhosted.org/packages/7e/f3/c9c3d530bb7bb6142095e5d0a10e9d73107964b4b6345c922809806f6eb7/coverage-7.17.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:65f74048adacb5b031186becc29ce2a12a8aa6f86df86562a947120f5d8e58bc", size = 227716, upload-time = "2026-11-03T12:38:05.14Z" }, + { url = "https://files.pythonhosted.org/packages/1f/40/cc5395ca5038c96637510122da45d58d023e50491a2796cb920eb25ee266/coverage-7.17.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:185ff7348ca70b1663b558a9a8ec66f34451c7a9428627543a0e9575045bed0a", size = 227882, upload-time = "2026-11-03T12:38:06.491Z" }, + { url = "https://files.pythonhosted.org/packages/73/89/5b8f9051cc86dba736c3b35538faa8dc4792e1b7140641531e65661274c6/coverage-7.17.1-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b0b4793548784c9986a4df4c90b9f672447a25c40783f1a736c7fe171a79cf0", size = 259735, upload-time = "2026-11-03T12:38:07.752Z" }, + { url = "https://files.pythonhosted.org/packages/47/5e/14081087f40abde7006010ba12cc3a0412de8088ab4afb857bf19ece28c9/coverage-7.17.1-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:834a15c96d92d2fa9503674c42615f843cc2f427b93d0a0a6c8e437ec728b1b3", size = 263426, upload-time = "2026-11-03T12:38:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/ba/2c/8c41550d3280cc71640905f0961e734488328627bd367e95451fd2b10df3/coverage-7.17.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:16903fc7d3e60fb9336ade7b12a8343f0381a1ca719d008b3d94a051b520a1c1", size = 264509, upload-time = "2026-11-03T12:38:10.656Z" }, + { url = "https://files.pythonhosted.org/packages/0b/d7/37d4eaf0313b042b26decc8b3d4f90baae3302b0e940074b4720b724392b/coverage-7.17.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6611d1cceadef78a6c136bb94d4e1d1db9024fe8f14b6ba4424e95bb2ac9e1a", size = 266883, upload-time = "2026-11-03T12:38:11.916Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c5/45823bfbb8d0c0d3ac69f6ad1fda556d87ee3d2bc930790ad12d54bc3484/coverage-7.17.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:efaa35a6671a9ce23d568e291edc5f97efe689eaa291a6468007cf12d3402e85", size = 260122, upload-time = "2026-11-03T12:38:13.282Z" }, + { url = "https://files.pythonhosted.org/packages/80/22/3b7eb82197af8a7b11ce57b1a3b2ecb891287a9016a77d3587051147ed8e/coverage-7.17.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:125b5146f8624275df6ade5b10d40fb18231ed8f79650a4c522adf7e300db963", size = 262389, upload-time = "2026-11-03T12:38:14.568Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ba/460b53c3ba449af2c70cb2ca5f2583d483b57fb9a15f2a964badbd8c18bd/coverage-7.17.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:08e6db8cef186e7954861705102d50d56f273026fce963135a029b1eed870955", size = 260339, upload-time = "2026-11-03T12:38:15.907Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6e/9a6f1abdcc0ce00de6aa28a2ccb5c622c0f4c4fc2365d4b18d54073eec9b/coverage-7.17.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:3832721ed2cae5d70ee4c6549ef166d16b41ff5c351fa0aae24463b620e65bec", size = 264672, upload-time = "2026-11-03T12:38:17.149Z" }, + { url = "https://files.pythonhosted.org/packages/82/b5/cdd25a9319af55fa504ba6cfc063cd38c1326b7382aa2f73a66e376ce5a6/coverage-7.17.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:b785cc3b82f469db18ca5b123c5eab7cf739d6a99be1fc5b4eb1c395dace5ab4", size = 259651, upload-time = "2026-11-03T12:38:18.475Z" }, + { url = "https://files.pythonhosted.org/packages/d6/80/273c406302ca223d3c72d2a277b1e776b4b21a2391c22fd2c4f41582949c/coverage-7.17.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2f09e92d9f3bc2f7193fd6b354a45817c89d3cebfdd0912900f67c7822af105f", size = 262195, upload-time = "2026-11-03T12:38:19.983Z" }, + { url = "https://files.pythonhosted.org/packages/81/ec/f2d4baf81838d3fe269090b26c98f5c48f6efb482ca365f852d72d0671a3/coverage-7.17.1-cp315-cp315-win32.whl", hash = "sha256:d27344a94963356614e884c5739871190438bce03d2973ff9c13be37d40c7371", size = 229634, upload-time = "2026-11-03T12:38:21.688Z" }, + { url = "https://files.pythonhosted.org/packages/e5/bd/6b6467a081d5da4c5fbd65908070bb9c6b90471738d74239a23ab8ef1e59/coverage-7.17.1-cp315-cp315-win_amd64.whl", hash = "sha256:4ebb24cdee700ba3987aa5c9bc773677cafb6d88edc6f6d9cf79bc0df96b473e", size = 230256, upload-time = "2026-11-03T12:38:23.307Z" }, + { url = "https://files.pythonhosted.org/packages/00/1f/522e0d03e2cdf4a7f2538d6858b64fb95a3193003bb0d79a42b6e1426bc2/coverage-7.17.1-cp315-cp315-win_arm64.whl", hash = "sha256:cbbfb4b9d99766653447f664622168e0d00fef41e6d25a7700eaf6d9f10ae0fd", size = 230120, upload-time = "2026-11-03T12:38:24.514Z" }, + { url = "https://files.pythonhosted.org/packages/bf/47/7ea4bdf31bf175b53067998a6e9b1e4e50fef191f0e3d4c426843dcc1801/coverage-7.17.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:9cd33f622f11927736fcacf884fc6a61605e9c15e489d24dc77cf84c7015ffe5", size = 228174, upload-time = "2026-11-03T12:38:25.837Z" }, + { url = "https://files.pythonhosted.org/packages/14/bd/05a784dffccc384aa939e3d4afbfed7c03dbbd4e56c15fa2262fc665a789/coverage-7.17.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:719b3925108a2ce55a6a9dd5bfd9bf9114c7da1c57b9ea39e59f0fc1ba9d4fa7", size = 228566, upload-time = "2026-11-03T12:38:27.073Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/c91c08cb288588711eaf448873536472aa6bec8e97e8f5c4bb7c3472f9a6/coverage-7.17.1-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:15981f51ef23c16de05e740677e1dbc59fd078fbf60ce4cb89687135585a791e", size = 268923, upload-time = "2026-11-03T12:38:28.267Z" }, + { url = "https://files.pythonhosted.org/packages/9c/96/99fc10e4eb6e64e6c613158c79805653366991b93293d18a1a62748e2038/coverage-7.17.1-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042e093be797b929741fb71238da028f0f2d9d669a3a7ab3588967d77f860b51", size = 271762, upload-time = "2026-11-03T12:38:29.534Z" }, + { url = "https://files.pythonhosted.org/packages/5e/33/fd2aa355efe9cceca9518a7b1f73623ff9a1deb2709cac2b8a096a1773ee/coverage-7.17.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:118f9bacb98a78b5e81c3a4721adcfb1b404942a5a2ec34e0d47a1ee7d772b3d", size = 274461, upload-time = "2026-11-03T12:38:30.828Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ad/e67a208e56876a5b632cfeff790804e331db581c9c5f439235bf40cfc13f/coverage-7.17.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0411fe8b17b7f481cdfe9138bd5b266bb18de124114cfab0cf796b61383ef321", size = 275794, upload-time = "2026-11-03T12:38:32.203Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c9/90717d790b248e1f081f9498d91050969de86d35c687a755db1c48ada4f8/coverage-7.17.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:af1f1c7057ff655f0e2673ca931ab9e69683c26841d7838a9677eb6484c637fd", size = 269483, upload-time = "2026-11-03T12:38:33.602Z" }, + { url = "https://files.pythonhosted.org/packages/3e/bc/162be11201171171e084cb388bdd8a44ccb820733a3cf13bd3da398e46a5/coverage-7.17.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:0bc7c1dbd90be3ddb3bab347deb91996bcb33828aa662acbe83334c55ee0642d", size = 271952, upload-time = "2026-11-03T12:38:34.874Z" }, + { url = "https://files.pythonhosted.org/packages/cb/2d/9ae1eb08020d998d4c9bb6e539b096642129eaec5cc423b0eca6ea216a3a/coverage-7.17.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:7c93a389c1f696ab7ca4764f6629dae187f41aac19ae763e18b35cd60dd7d2b4", size = 268977, upload-time = "2026-11-03T12:38:36.164Z" }, + { url = "https://files.pythonhosted.org/packages/81/6c/33577528fdb8a9d6af5e5f188c28a364d5ed82c57c49dcade7e96682da06/coverage-7.17.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:208ecaaa274e8c97ff8939baa15cfd4e9a5ed0b7a0132206548277e7938e96e7", size = 273587, upload-time = "2026-11-03T12:38:37.412Z" }, + { url = "https://files.pythonhosted.org/packages/5f/a7/6449f497df0012d8e793bab0788d0265d9d2753b33b64fbd47ce8dc50eed/coverage-7.17.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:043af54ef18a5ea6ec5c5347408d21165fd5ddff4f62f63efea32cf3c0ba6ca1", size = 269072, upload-time = "2026-11-03T12:38:38.858Z" }, + { url = "https://files.pythonhosted.org/packages/9f/08/35148999d7e8bef6e596cc056d5a7a403d2c702daa5b51e22d138056b254/coverage-7.17.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:8830f81b489c1fcba77338cf9e176d253117dd886fb58e587a137f9f5bf9b062", size = 270684, upload-time = "2026-11-03T12:38:40.155Z" }, + { url = "https://files.pythonhosted.org/packages/fd/bb/6c0714bcd3ed4b9ec00902281dc17fcf59eb308185ae78e7bea2f037dc20/coverage-7.17.1-cp315-cp315t-win32.whl", hash = "sha256:f705761e5187ba08bbc80fd4b5b6d675e23ecc4f468daee2f5b22cfc8f5ed96b", size = 229942, upload-time = "2026-11-03T12:38:41.524Z" }, + { url = "https://files.pythonhosted.org/packages/5c/34/8d88d51ff9c3da15430c902aca5409a98c01b8d7fad18d631daa53df734b/coverage-7.17.1-cp315-cp315t-win_amd64.whl", hash = "sha256:87e86e0c7712ce64316f649c6d0b30225aaa64da25ff201bf6a1d86d21168d73", size = 230870, upload-time = "2026-11-03T12:38:43.146Z" }, + { url = "https://files.pythonhosted.org/packages/8e/58/9cdb5667edcd9bd5b17293e96620e50e89d425d8a450a1fa57f18e68b5d9/coverage-7.17.1-cp315-cp315t-win_arm64.whl", hash = "sha256:9cd4319b51f18519688baf38e01424ec439a5da5ef034a7e429bc631afa95e63", size = 230443, upload-time = "2026-11-03T12:38:44.433Z" }, + { url = "https://files.pythonhosted.org/packages/18/61/7ad3e5f92557c73044d3dfaf88cc65fb7b1ad589c744e8629af8e6370224/coverage-7.17.1-py3-none-any.whl", hash = "sha256:fda1023828e4a9f4a40ef06783e005f3630f805f839edc679c87f597f33e041f", size = 219074, upload-time = "2026-11-03T12:38:46.229Z" }, +] + +[[package]] +name = "cryptography" +version = "50.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/af/182eb91b0df3fe75c4d9f26fe70684569566745f6ba7e5c9c73a862c5252/cryptography-50.0.2.tar.gz", hash = "sha256:7b46165bb56eb4704e2eaaf86f3c940d19154535d9b0ca7d6d590b04060e00d5", size = 880623, upload-time = "2026-09-30T15:30:04.884Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/69/c9bd862c3bf43d6399c433caf002df16e2dffd4be49bdf515cda38038711/cryptography-50.0.2-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:79def8d059362e7831389ed3be0ecdf58a89386e1271e35dd9f5af84e81bffd0", size = 4731146, upload-time = "2026-09-30T14:43:47.113Z" }, + { url = "https://files.pythonhosted.org/packages/21/69/64cef1f702bf6657e0cc186ed1a2891d50d29fb41586b254e1c07adea261/cryptography-50.0.2-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:630ebfea3bf689d075f82316324ff7433dc447fe6bc1bfc76524b74b4a9567d2", size = 4719841, upload-time = "2026-09-30T14:43:49.01Z" }, + { url = "https://files.pythonhosted.org/packages/38/6b/61a3f8d8c5e1e49a6cddccafc4015cc1c0021360ab0acb4080e7a423644a/cryptography-50.0.2-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f9f6143a8c75945eb960d9eb98905a441394abfa24afaae239d514ffb2586480", size = 4738340, upload-time = "2026-09-30T14:43:50.932Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f1/b474e930c4d910328780e3940da76f5aa5cbc48ce1fc14e44d239d9ea9db/cryptography-50.0.2-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:4061c0079120205fb760c58acab6443e217307dcf05e3702cf970e0689972856", size = 4753050, upload-time = "2026-09-30T14:43:55.272Z" }, + { url = "https://files.pythonhosted.org/packages/7c/52/9af10e80ac16b0fcc2123f9cbd5e7afbd0fd5075bb7a607c592258a39cda/cryptography-50.0.2-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:ac9ed99d81760c62fe89d5f0815cdfa1ba9a35141cf30f1c2d044f04b4803d2e", size = 4376724, upload-time = "2026-09-30T14:43:57.24Z" }, + { url = "https://files.pythonhosted.org/packages/71/37/6202e488cc1eb625ea110c292c6bda92823176e023f427d8d5660ce8d632/cryptography-50.0.2-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:87e9ce85beb6b328ba370cc6e6aea483c92617b4c95b1d33a49297eb662bfb04", size = 4737859, upload-time = "2026-09-30T14:43:59.541Z" }, + { url = "https://files.pythonhosted.org/packages/d3/69/2c833a049475e0a3444e94c7d0aca0aa51d166374a449b09e92ac98138de/cryptography-50.0.2-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9dab55f57c74c3cad24c323bacbbd04be4705ba6eb0d92e920b1fc4837ed5079", size = 4752576, upload-time = "2026-09-30T14:44:04.545Z" }, + { url = "https://files.pythonhosted.org/packages/6c/5d/906970b83bbfc1f5bbfb677a143c181f2801f23b6a7204a3b47c42c97e65/cryptography-50.0.2-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25784ce8b9621c90c643efb9e1e2162ab3b0224cae446ad5e70e7fcb1ce18b51", size = 4870819, upload-time = "2026-09-30T14:44:06.884Z" }, + { url = "https://files.pythonhosted.org/packages/68/e3/f2298d3bb55e0c4a91841ec4d01b3f020ba8c5fbf15ccdcc6dcf03f97025/cryptography-50.0.2-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:85d0d9a31b9098e98534226d5686b47264b95e62ce459dc2e62fdfc809f9fe93", size = 5030152, upload-time = "2026-09-30T14:44:09.443Z" }, + { url = "https://files.pythonhosted.org/packages/19/8e/aa1fc533d4546b127b45de8aa024eb5933d23eff9debfe25931e56861095/cryptography-50.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0ecbc5652bdb6fc9eaf89a7d196e20941adfe812f43bc4ca05d9150496821047", size = 4710431, upload-time = "2026-09-30T14:44:15.427Z" }, + { url = "https://files.pythonhosted.org/packages/6a/64/72bc3f75176e7e406b748a3e3830432b8c51297b38368713df04dc04898a/cryptography-50.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ab50ee449bf968271e820086f10a33d101dd060370abc10bcd22279be2656539", size = 4694824, upload-time = "2026-09-30T14:44:17.69Z" }, + { url = "https://files.pythonhosted.org/packages/4e/c6/62c77550edfa5ca3f14bf44a1e6739b9fa09d6e998a11d97ed8213bccc98/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a9f7355e6fab51f6c369b86fb7571cffa05edee2c2121e0380a37fb9ac1cd5c1", size = 4716967, upload-time = "2026-09-30T14:44:19.661Z" }, + { url = "https://files.pythonhosted.org/packages/aa/9a/6f2f0304d634ceafdeaf23e84537336664ac419b5d07611675c2ad3f6b7a/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:241449bf940a5d27309bd317e6f9a2af6932113818bb2b8f5c59ddc7ef16da18", size = 4727698, upload-time = "2026-09-30T14:44:24.178Z" }, + { url = "https://files.pythonhosted.org/packages/1d/de/66bcf9244d118663b2e1aaded8990f4640e3d7b7411870a5765f252074d2/cryptography-50.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d8947001be83df1394050758ce0e745dd74fb134eef0a4b5124208dfc3a68c37", size = 4354821, upload-time = "2026-09-30T14:44:26.263Z" }, + { url = "https://files.pythonhosted.org/packages/bd/e6/db28a28c7b6c676addce89136de3d8db49ea825a8c863472e36e42ead4ad/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4a20ce1e5cb4284a86692fdcba7cb8754185c6b2e5c56fcef3751cf451d3cdc2", size = 4716748, upload-time = "2026-09-30T14:44:28.447Z" }, + { url = "https://files.pythonhosted.org/packages/6c/01/03263395f74d50b071e9e66daace3f8bef80493e5d410726f2ba8554736b/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:828d49b0ff5a0e3975865571c5d91dbbdd0d38d8289b249a163e9425413a5e05", size = 4727268, upload-time = "2026-09-30T14:44:32.92Z" }, + { url = "https://files.pythonhosted.org/packages/eb/94/2bfe8f29ec0cc9c0d99359c4161adf32858e4934b72c6d100d2ac0bbe962/cryptography-50.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:deb9fde5c60e437ee4821bc9bc39ff31b42135c27e1dc61ef0a629389c1de62e", size = 4849503, upload-time = "2026-09-30T14:44:34.969Z" }, + { url = "https://files.pythonhosted.org/packages/54/44/e80651ecbf0e42b62e2bb5f5768916e07eea72e1297338956a61df361f88/cryptography-50.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8c71ba2cd31fc93748c38e1b613200ff1c2665cbfd5341fe3a61cfde35a1430e", size = 5004057, upload-time = "2026-09-30T14:44:37.064Z" }, + { url = "https://files.pythonhosted.org/packages/8c/75/32ac2a56243d778805c16ca6a32b8f74fb757df7e28d7ecb560afafb59cf/cryptography-50.0.2-cp315-abi3.abi3t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d370b8d1dfcdf7130178137f6fbee6140774a1acc6cacefc4b42643ec11d0a3a", size = 4956267, upload-time = "2026-09-30T14:44:43.693Z" }, + { url = "https://files.pythonhosted.org/packages/aa/a4/2c8d734e43d97f0842ee9f1b7b4bfb3d0cf5e19edebf43c2afe6675c2320/cryptography-50.0.2-cp315-abi3.abi3t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f2f9bd7f90c64fe89253f0a2c05e3c4856072660429ce8831b4235bf29403a67", size = 4966465, upload-time = "2026-09-30T14:44:45.769Z" }, + { url = "https://files.pythonhosted.org/packages/c2/58/ee288c829a6f41f6235ae9dd33d82fd19b45442b65b4c8a3da36963d9f7a/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_aarch64.whl", hash = "sha256:e275096ea1e60cc595cda2836fd4a6c725d1125108b868be17f53684d164e2cc", size = 4959356, upload-time = "2026-09-30T14:44:48.211Z" }, + { url = "https://files.pythonhosted.org/packages/02/a8/8df951850d6b31d2a00218f19e2b3f999523437ed7a819df7fa427942fca/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_x86_64.whl", hash = "sha256:58a0c478eeca76fe5e07993c5a0703def34a6dc6a0cda4f5564639b33112ffe7", size = 5001199, upload-time = "2026-09-30T14:44:53.379Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f9/36b3022218ce75b7cdf068fb95f809f9bd0d820e4955ef43b90c255cc7ac/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_31_armv7l.whl", hash = "sha256:d38cdff612d06fa6a32840d5e1b1f7a27cee4a349aa9085d94a67789d6bfd408", size = 4629333, upload-time = "2026-09-30T14:44:55.635Z" }, + { url = "https://files.pythonhosted.org/packages/8c/72/20f99a219f6af47cdd1cbd978c243b92d71496e168a746138af44ded4f29/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_aarch64.whl", hash = "sha256:fdd28f912fccfec1846a94e2e1e8f9b0012f557f0c46fe4f3eb0d7a87afcf90b", size = 4958822, upload-time = "2026-09-30T14:44:59.639Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/83378121ef3eaaaf71d4b781577ff794acb39b9e1b87a3f156898c8497ed/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_x86_64.whl", hash = "sha256:e105ab60406787da31fccc883fc0f733af1efd78f0136a4599692c4083a73d0c", size = 5000859, upload-time = "2026-09-30T14:45:05.009Z" }, + { url = "https://files.pythonhosted.org/packages/22/f7/70fd7ae4d1dbfa7ba29b02e1b9068771519a86027756510b700ce81086a8/cryptography-50.0.2-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:6f8700550aa1474a91e5dc07049c46f98b423b5b1ddd0483e0b51362eeeaf5be", size = 5092151, upload-time = "2026-09-30T15:29:15.932Z" }, + { url = "https://files.pythonhosted.org/packages/d4/be/688367b74de86984bd58d8efacfc7c9e68b89a6a22ced0fb4f38db50254a/cryptography-50.0.2-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:c71be1cbfa5cd9a41ee452acf1eccd82b2c05950358b106ec8ceb83411d1a020", size = 5286120, upload-time = "2026-09-30T15:29:18.309Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8d/6d585339bedf85d45044c85d8412dac53f2bb6f918e8b7777efba1787844/cryptography-50.0.2-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c5e67125c7dca78d199ec4e116aa93dbb83494808ecbb8211a2cb09b1bf41dbd", size = 4756166, upload-time = "2026-09-30T15:29:24.58Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f1/1c1f6874e8550cfddd4b688ceb38cefb6ed15ceed224d56f133f3d88c214/cryptography-50.0.2-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee247f5c245c9a2fe7c8e2214e295918838e44e00a45a6718451e4004219e767", size = 4749145, upload-time = "2026-09-30T15:29:26.807Z" }, + { url = "https://files.pythonhosted.org/packages/c1/63/61b15dc1a8de03fe0adbe3fd7608b3ad5c73bf50993bbcb1faaa930afe33/cryptography-50.0.2-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dfe9763530994147d9af1def057a5b9658b00e8f8fe8743d144d1e0911c2e454", size = 4763638, upload-time = "2026-09-30T15:29:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/4f/87/ef344a9e616871f2519c22d6afcda79ddd5d35e9592d95eb6e677608d055/cryptography-50.0.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f21e8a22c8605750c7af886bab299a363721264061b4ac0a30efb73cfd58efc5", size = 4781387, upload-time = "2026-09-30T15:29:32.605Z" }, + { url = "https://files.pythonhosted.org/packages/90/5b/f2fdb13cd0b96f6f932c8627bb292a45f11c64d21620a8e120aee9a3b848/cryptography-50.0.2-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:9c8402a82ea0dc4ceeab793db05f0fafa8ca139ca34fcde5df0f596103c74107", size = 4403790, upload-time = "2026-09-30T15:29:34.374Z" }, + { url = "https://files.pythonhosted.org/packages/bc/ce/7e4f662b1e3c393513569e402cfc85ac7da0bd3d5435e122a3140219eb2d/cryptography-50.0.2-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:0ddc924c04591c2811ca024d62ecad4f7f6f08af8939c211438f48a16bd23602", size = 4764319, upload-time = "2026-09-30T15:29:36.149Z" }, + { url = "https://files.pythonhosted.org/packages/40/cf/6b5c8e2fd9202d98988ab7cb5cc5c991704c4ad55f492ff408e4969f83f1/cryptography-50.0.2-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:1981f1db4630889b9ef7803fadef12b056f428cb6b85c27ba57b774793b6093c", size = 4780973, upload-time = "2026-09-30T15:29:41.251Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/8d6ebc7dded797bd0f0160d52188021211f011a2b164ef0ae1dac4587465/cryptography-50.0.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7a8701d6b584d76e909e3d305b7d126b41439876a5aaf76cddc67fc230eafa2e", size = 4897738, upload-time = "2026-09-30T15:29:43.106Z" }, + { url = "https://files.pythonhosted.org/packages/d4/aa/f3f6e0de7e6253b8baa8b2d8fb9d50924fa75cee3d4624bd4bc1208ee923/cryptography-50.0.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ce47f66801c20ec6c6632453bb5960fe38939e9306970b48b3a5a26de7745d94", size = 5058280, upload-time = "2026-09-30T15:29:44.827Z" }, + { url = "https://files.pythonhosted.org/packages/1d/7a/f08d34ce09d60f89ebd391e2ebc6ba2b995e6dd7552f41820f8085f94e53/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:92e665960f25fcdc73725b9cec7a3824f279ba97a98653afe9ffac2e43668f67", size = 4716035, upload-time = "2026-09-30T15:29:48.681Z" }, + { url = "https://files.pythonhosted.org/packages/45/67/e18fb65592451a2acb76e9f2fbe14e0f47a8318b4c5430f1633851d03daa/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:eef4c2f3423810b3070ab391f85436d2f8bbfcb286ac15cbc73190b3563b1f1a", size = 4726917, upload-time = "2026-09-30T15:29:50.608Z" }, + { url = "https://files.pythonhosted.org/packages/83/28/38fdce17e60f6b825e69fc3b7f75e70a6612759980704697e1de4cbfaf6e/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:7c6d0330c472d96f6a6afe24d80dfdf15176c33096f0a4397ae4c60f3dd3be48", size = 4715341, upload-time = "2026-09-30T15:29:52.522Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b1/d9121a717e0f893c64bd6ca7702614778d7df2a5c309128a002421788516/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:1ba34f04897fcdaa73f74145c25f3ec146fbd56593853e88adc2e811303c5f42", size = 4726322, upload-time = "2026-09-30T15:29:54.263Z" }, +] + +[[package]] +name = "cython" +version = "3.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/99/ca/18e324972e5cac914816fdd7bb03e19a455b90039c277a538f7781b50c85/cython-3.3.1.tar.gz", hash = "sha256:e0e45989e821bef6aa9ae15c7d583ab5e055f7406c4b3624e49e06d24e90375a", size = 3743354, upload-time = "2026-11-01T20:12:04.773Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/e1/bad59c9ce7931f5c2b7cd9d5228d16926373267bb841aa8a4b29a1ab3c3a/cython-3.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0ce9efd76bfbf7b67be0da80d450231e1c1bdd5e755d7a8dc10ffc2669fc5edf", size = 3135399, upload-time = "2026-11-01T20:12:28.657Z" }, + { url = "https://files.pythonhosted.org/packages/21/33/cb2588a238d862ebc5e973acc3504ec28764bcc4273828f8e0915354415f/cython-3.3.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:43b16388665cb829c265060705900db8e26e9c3c04cc91f28af38c905d12293f", size = 3351071, upload-time = "2026-11-01T20:12:31.078Z" }, + { url = "https://files.pythonhosted.org/packages/5f/78/1e8562e6dc57f6b9398bc754dcaf574f71762a5a637bb6525ae06cdc7f91/cython-3.3.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26a28e0ca5dffe9c7d69d1e3a0f78cb74f41b2b6b40771f620262a5d04862a00", size = 3483723, upload-time = "2026-11-01T20:12:33.044Z" }, + { url = "https://files.pythonhosted.org/packages/de/44/55cfaaba499dcd06fb998bf64d3839f7208e80b2acb1dabcdec515d26bf9/cython-3.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:298d3e46d1d4e2f4405d2c934b51899482101a0b0dc43b1b13b2e38f87addf52", size = 2866366, upload-time = "2026-11-01T20:12:35.09Z" }, + { url = "https://files.pythonhosted.org/packages/40/3f/362d57b505de56a3a24f84a94b2e09772ebbc9d05402e9c3bbe7b1b780a5/cython-3.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:744bb804252cf204e6bc9b0fac06b3bad7bb14258cefb9f321c59c4c59e9bc17", size = 3145239, upload-time = "2026-11-01T20:12:37.11Z" }, + { url = "https://files.pythonhosted.org/packages/4f/9d/016dfaefc1a10e182fd770e6c331ebf79df88a527883b4ecbdd74abb9969/cython-3.3.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f08b3eaa639005bea6ab119ebbd6e30656e448981e7a124d80b409760d06c15", size = 3262357, upload-time = "2026-11-01T20:12:38.861Z" }, + { url = "https://files.pythonhosted.org/packages/4a/c6/51ffdd996a1e6836792061ebe7ecf40480f1bd5693a721cea0ad4a689a81/cython-3.3.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:215669fd0ce792080cd4d0748db7e1e31f424b6706a6220d08339895e6a3a03a", size = 3418124, upload-time = "2026-11-01T20:12:41.076Z" }, + { url = "https://files.pythonhosted.org/packages/4c/6b/de4b5b3f43bccd82ef48071a33c48315098867eafe6ae3a39f1064f8d331/cython-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:fd81cfc6e94c43c5c0fe50439c11b90dc89cc6b323f92b37edc6a951d0a619d7", size = 2875470, upload-time = "2026-11-01T20:12:43.169Z" }, + { url = "https://files.pythonhosted.org/packages/4c/c1/15881737c54e90c83ff314998b363a2069ec184bf642f2cce9222dc631c8/cython-3.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6156be528b46e820ba834449716690d5065049ff355f261a8600f7da6b436d96", size = 3136530, upload-time = "2026-11-01T20:12:44.807Z" }, + { url = "https://files.pythonhosted.org/packages/64/db/73a6f5f560b7f77fa5f2b5dca15f761f0598776f47951356449e162a4514/cython-3.3.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d0f2610ce850d264e29a87b3d9b8ec4f0f2dec5bc1dce0398294251f09b149df", size = 3257359, upload-time = "2026-11-01T20:12:46.783Z" }, + { url = "https://files.pythonhosted.org/packages/a3/04/5445c845d08948b4006c72b5bc202b63f108ff0b87161a993dc5922106a0/cython-3.3.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85be5442e8f465c7c5e80837ac2a85a2ce04034e616445113092e85b65d0ab94", size = 3413336, upload-time = "2026-11-01T20:12:48.701Z" }, + { url = "https://files.pythonhosted.org/packages/e2/2d/8afe74009f266c43033dc54d851f31edadc414842cc061bd2762ffc9737f/cython-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:0f7d52979bf7730351cf9ca2e9257d4b80f729053b521159bab8666e6be7e3bd", size = 2869329, upload-time = "2026-11-01T20:12:50.577Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f4/2892e59c7e75e75766021c40c165a30edbbfdae4efb6e10cb3fd23486b66/cython-3.3.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3370326802b82cc7cb7df65e605e1acfebdce193077e27ed5734b9bc3f7c6ad0", size = 3188251, upload-time = "2026-11-01T20:12:52.507Z" }, + { url = "https://files.pythonhosted.org/packages/8d/94/dad3d60dcbf22616ee6564456ffc3b6594d5cac9b91735f34ab90633326c/cython-3.3.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0eac1184dd57591a8f3d25691c7a6bf7db030f515b210691bd251772a7e70a4", size = 3335776, upload-time = "2026-11-01T20:12:54.507Z" }, + { url = "https://files.pythonhosted.org/packages/07/d4/6cb0c23f8f3e7081c3af03ccf685a73cfa86af85725b9f4c44040e5f8858/cython-3.3.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a6c191617853f2e0d5936c73f5d5cd096548f4d9e0fa37612ef721591c42cb3", size = 3459005, upload-time = "2026-11-01T20:12:56.224Z" }, + { url = "https://files.pythonhosted.org/packages/82/69/8efe9179f9f139d4fbe367e5e76e40673c87450f3f4ed1a5c1350be365bf/cython-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:7bcc6de1603d8180667b40f4014be142d7d62cfc10af0184ad8d6a83847a2ced", size = 2928989, upload-time = "2026-11-01T20:12:58.247Z" }, + { url = "https://files.pythonhosted.org/packages/cb/37/231f00ec8f6a56519aea9cef921ae9c5d4c39edd8b5557d0de9048211004/cython-3.3.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:a1bfd7511fe8d83f5e681876df22878efac5cd5b2c174f272e6bf018c8fd4a91", size = 3179367, upload-time = "2026-11-01T20:12:59.906Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b1/a0ed5165b268fe2d52929e08e9e89278b6f2eeee1c49c9976ba64ef194b7/cython-3.3.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bce8f37f50add0432ac802cfc34e5bd16395f2918ad1eaeb50b26d02c9001014", size = 3331494, upload-time = "2026-11-01T20:13:01.774Z" }, + { url = "https://files.pythonhosted.org/packages/63/e4/4ef74af67d86067258187a24764df2d9d9bf9adb0b78712862dea051eaff/cython-3.3.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fcb6c86dddaedd1da5d77ba2469c1a4bea52442e02d8f0653ff78667fbaaa8d9", size = 3456176, upload-time = "2026-11-01T20:13:03.833Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0e/0458355eb10a33315ede98d91a40b5848f3302cf4e9b44c70211a592ae3a/cython-3.3.1-cp315-cp315-win_amd64.whl", hash = "sha256:45dd533a87c9629d02d77c9a5b48cf399907a99e4bb556aebafd2ac4b68580d2", size = 2927687, upload-time = "2026-11-01T20:13:05.712Z" }, + { url = "https://files.pythonhosted.org/packages/d7/4e/548df758dbbea481ab054e062933252753b8db86757894bbb1fa84bd9292/cython-3.3.1-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c4e4132b03a6c6c11541f7498441224f55a9e101c615d49494983d2b10dd7669", size = 3066885, upload-time = "2026-11-01T20:13:07.719Z" }, + { url = "https://files.pythonhosted.org/packages/87/55/61840ec209f861887ca547c75c401a493be6c034c1d9ad8f9b628b607054/cython-3.3.1-cp39-abi3-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:226d791808ce95f20ab1b3589082be604b5b5b31e670bf773ef9c312d2f0a8c2", size = 3361449, upload-time = "2026-11-01T20:13:09.398Z" }, + { url = "https://files.pythonhosted.org/packages/96/b1/16e743c3fbfa6424d9c94430934b5bde3a696e7b72c1476e284fdcd1210f/cython-3.3.1-cp39-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4d1f9d6fad7a8d9750b641a941cd841ec43740a375cb2fdb934329a17fa88b36", size = 3044439, upload-time = "2026-11-01T20:13:11.239Z" }, + { url = "https://files.pythonhosted.org/packages/59/4d/5e19712c074564e696731df56242c7626001b5695d09798115d788cbd771/cython-3.3.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:73f6f40f9308e77cbdb3259155d793ac189ead6687b9a432f1b4503170cb9a13", size = 3157847, upload-time = "2026-11-01T20:13:12.87Z" }, + { url = "https://files.pythonhosted.org/packages/39/16/d6517f078e69f0e5b224b0f1109851408f240af70982d1ef61c53f3a2df9/cython-3.3.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:801730e5714a40dbab8a373af36110de8ff161ec056c855a9627cf05fbc8a6d1", size = 3049217, upload-time = "2026-11-01T20:13:14.506Z" }, + { url = "https://files.pythonhosted.org/packages/78/5c/539b55fa787a427b0dd0e2ba805c04acb108fa65c69ff76e901d44e4a2d2/cython-3.3.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:a2bdb50e9fe8974447b68edc5b0201573b06d2c5683f472a5fc08e1792051277", size = 3376191, upload-time = "2026-11-01T20:13:16.383Z" }, + { url = "https://files.pythonhosted.org/packages/8d/dc/ca2ea10c22499e00d366a9252177ec9039b8d786c85fd28260d41ec2dda5/cython-3.3.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5febfc8c52aced0cf9360e6f2304428a5fa0e66fd9aa7338d5c41f0ce26dd104", size = 3267528, upload-time = "2026-11-01T20:13:18.074Z" }, + { url = "https://files.pythonhosted.org/packages/66/89/b2fdb92a7ccedff602f362bdf3fe38d67016de8c6655bc60bffce98b923a/cython-3.3.1-cp39-abi3-win32.whl", hash = "sha256:b0265a0e186af3c38339c561507e98e2e3a0d377cdb2b0427f980138ceddd4af", size = 2590014, upload-time = "2026-11-01T20:13:19.925Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d8/3d620697d89110b58937b1297dfdafbbfec4415b11b845b46ec9a04b52b5/cython-3.3.1-cp39-abi3-win_arm64.whl", hash = "sha256:8b4391d39260efedeff2e3914e958b9ed75cb2b40f10b62bb0e9ca002658563a", size = 2693762, upload-time = "2026-11-01T20:13:21.506Z" }, + { url = "https://files.pythonhosted.org/packages/9d/55/088578d75bc8dbcbc535af04b1d596ff227ca756dd74f9d3c1c526f955d0/cython-3.3.1-py3-none-any.whl", hash = "sha256:61abc7feedd20dac6c4ff7ab3a30e17136a067b242ab9253e2b4a6d9a72c2b61", size = 1352000, upload-time = "2026-11-01T20:12:01.888Z" }, +] + +[[package]] +name = "distlib" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/d36966de7304047a1001a7559fbf266c464bb5d8cc85464536ef8c9bcc32/distlib-0.4.4.tar.gz", hash = "sha256:ca4175b4ac7f71223cc30ed7248c45d2b38c2439d8ee6e498ab67ed63cf3508d", size = 621304, upload-time = "2026-10-16T13:56:34.203Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/2b/238f02a4927fa2e27aa995371d240a468b52e42eae44a678434aff736b38/distlib-0.4.4-py2.py3-none-any.whl", hash = "sha256:cf09d55b1e85a89576b036aeb71550bfd68320f3f21761ca329eadadad918638", size = 472099, upload-time = "2026-10-16T13:56:32.053Z" }, +] + +[[package]] +name = "docutils" +version = "0.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/39/a4/5180d9afc57e8fca05601dd652bdff19604c218814037fe90ffc7625a50a/docutils-0.23.tar.gz", hash = "sha256:746f5060322511280a1e50eb76846ed6bf2342984b2ac04dc42caa1a8d78799e", size = 2303823, upload-time = "2026-05-27T17:41:06.934Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/91/30151a39f7570f448ed84529390628a651d7f27c87d73c9b887f8189695e/docutils-0.23-py3-none-any.whl", hash = "sha256:25d013af9bf23bc1c7b2b093dff4208166c53a94786c9e447808335ef1185fea", size = 634701, upload-time = "2026-05-27T17:40:58.442Z" }, +] + +[[package]] +name = "filelock" +version = "4.2.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/14/73688a22e91cfcfc6837a011ffa572e2ba3c348765f7bd482d8436fa9b6f/filelock-4.2.7.tar.gz", hash = "sha256:31f6f7e3a8b6f0bd89114d30c5d5218ea1cfb63e5c4aa695b7559314a209bc7f", size = 661450, upload-time = "2026-11-02T16:09:15.119Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/1a/1fcf0d3886bad15b92459a0e529dd86a1ec4d9ef30e789df48044fd3698c/filelock-4.2.7-py3-none-any.whl", hash = "sha256:d08972bbca2b8767ee552aff877b091dd111ffb1d22de7de885766ea7d719d5e", size = 164345, upload-time = "2026-11-02T16:09:13.588Z" }, +] + +[[package]] +name = "id" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/04/c2156091427636080787aac190019dc64096e56a23b7364d3c1764ee3a06/id-1.6.1.tar.gz", hash = "sha256:d0732d624fb46fd4e7bc4e5152f00214450953b9e772c182c1c22964def1a069", size = 18088, upload-time = "2026-02-04T16:19:41.26Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/77/de194443bf38daed9452139e960c632b0ef9f9a5dd9ce605fdf18ca9f1b1/id-1.6.1-py3-none-any.whl", hash = "sha256:f5ec41ed2629a508f5d0988eda142e190c9c6da971100612c4de9ad9f9b237ca", size = 14689, upload-time = "2026-02-04T16:19:40.051Z" }, +] + +[[package]] +name = "identify" +version = "2.6.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/35/d70c0006c7cee65999ea94a6273e60b2094f600a3d8b71b04318253fc643/identify-2.6.20.tar.gz", hash = "sha256:ad729860a923858d26917c2f4fb0a1d83d27a75b1e090c06440c573f048f3285", size = 99681, upload-time = "2026-09-26T20:29:07.187Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/70/fffc9613501877c0a10a1ef73a165e6ded3e53f6e7502227fef56d973933/identify-2.6.20-py2.py3-none-any.whl", hash = "sha256:6a16b69b93187244e0548cbfd25b3e4a6f9a7a2ad784625c3bec2b8d27b81aaa", size = 99506, upload-time = "2026-09-26T20:29:06.054Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "10.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/f6/4eda8458eb00ec03e715c376c6b23b3def69687924c68d36d1c4003d3bc4/importlib_metadata-10.1.0.tar.gz", hash = "sha256:82b04047fa09792c1a8cfeddfe08bec79e4b13c29c8469b0d3949860f61017e8", size = 67761, upload-time = "2026-10-24T00:01:44.856Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/65/b6/495438ad95e0102aff8f6786b5474202f38cd5d4700d03a72b77977dec10/importlib_metadata-10.1.0-py3-none-any.whl", hash = "sha256:cf45ce66a929c64e994185a809c04840d0501db17e663810d993d0f4829265c7", size = 32221, upload-time = "2026-10-24T00:01:43.507Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" }, +] + +[[package]] +name = "jaraco-context" +version = "6.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "backports-tarfile", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" }, +] + +[[package]] +name = "jaraco-functools" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/1f/c23395957d41ccf27c4e535c3d334c4051e5395b3752057ba4cbaec35c56/jaraco_functools-4.6.0.tar.gz", hash = "sha256:880c577ec9720b3a052d5bc611fb9f2269b3d87902ef42440df443b88e443280", size = 20837, upload-time = "2026-07-14T01:28:02.544Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/36/ecc85bc96c273dc8a11273ed4782272975e6338d4a3e9228621175edf0e3/jaraco_functools-4.6.0-py3-none-any.whl", hash = "sha256:99e3dc0060c5cbe8fcd1cdb36258e2a65ca40f1566b2033b12abb1bb44dd3c30", size = 11677, upload-time = "2026-07-14T01:28:01.59Z" }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, +] + +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.12'" }, + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" }, + { name = "secretstorage", marker = "sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" }, +] + +[[package]] +name = "librt" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/04/f5/9dc696772d241814bacac7880bac32f2930b5a6ebc1f85317b83161a011c/librt-0.16.0.tar.gz", hash = "sha256:ac38d6d8d66bf3d744148dbbc0b8e193e195a51e364ed55e224631f5721891fc", size = 219839, upload-time = "2026-09-29T00:55:32.891Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/0e/b04fd2d76b6a78a02286938251b2c119fb36ddece92c76cb4886ef7d44b8/librt-0.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fe4372c52d4849096c6cc1cda2817d293ec51440c890474ed59ef38d46556f18", size = 148058, upload-time = "2026-09-29T00:44:40.903Z" }, + { url = "https://files.pythonhosted.org/packages/a3/fc/e1ed24aadb32d38603c0c07f579d739eb4d90e64e90d525b024e4a999b4d/librt-0.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c72c5295a84bd249526da9bdca38f2e176d15c31c13bb0063c5053f4ca023421", size = 153073, upload-time = "2026-09-29T00:44:42.165Z" }, + { url = "https://files.pythonhosted.org/packages/be/38/133ab655409420e0c34a9a9836a7f4e5ae75fba758d7fe177099130d58ba/librt-0.16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be56ba9c884143495b517f23fe794ae367d58cd89ea0fdd6d437e3c024a87f9f", size = 493052, upload-time = "2026-09-29T00:44:44.043Z" }, + { url = "https://files.pythonhosted.org/packages/94/42/aaa663bc9421f5bf7bbbe9d3316d7219749698ec7688ac3b519770a89c04/librt-0.16.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:ef46c1a29ffb8c72e882e22618ec618778eacd0578fb22c6e7cf9c11d15f357b", size = 485506, upload-time = "2026-09-29T00:44:45.479Z" }, + { url = "https://files.pythonhosted.org/packages/7b/59/83a6eb5087ba8b45b083859e2085256963e06d4c2531944cdd962670bfb5/librt-0.16.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d3c94211ee0c4f8d649ec06b7c115c0ec4eadb873a0e3154ca15cef3f814b071", size = 498708, upload-time = "2026-09-29T00:44:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e4/15a8d62b2bc12935080ec7277e2e0b9b233047781eb784a51d3e25af669a/librt-0.16.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94aed6a8308818b91677957d1bd03188869cd7aeb23c5dba7912a6c0402f7602", size = 515981, upload-time = "2026-09-29T00:44:48.316Z" }, + { url = "https://files.pythonhosted.org/packages/46/4f/287cc282ac5dd815204c0779e79401bb0a568c3a1335fb319bf0838fb566/librt-0.16.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:349c0bcb87ebd07481b6ff781e25cdc699723dbe2212e57dabb27f7a13b7b87d", size = 508670, upload-time = "2026-09-29T00:44:49.726Z" }, + { url = "https://files.pythonhosted.org/packages/bf/5b/ab7292add898ade0d2b5b75d32a923aae315861671aa5c39f5491309f7ae/librt-0.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:001bfd59a7d45b17e3e75f2a8c6405280b35e7b84471792778e718c4f368950e", size = 530393, upload-time = "2026-09-29T00:44:51.356Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9e/8e6bcf027d4bcbc16a4e864b3d158a1d3e5f55ffa53af0238020cad89271/librt-0.16.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:28e038895b998d7a0c7798922ce8a1dc157675df5cf1c9ef0aca809ed804b7a1", size = 534302, upload-time = "2026-09-29T00:44:52.893Z" }, + { url = "https://files.pythonhosted.org/packages/96/a4/8c5ab4f3b3a8e905ff8305d76976a2e666f52fe049edd398aed2402beb36/librt-0.16.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0dbe4096a7ecc00fa835d24510ad8545a4efef738dac96e0e63516783ccde905", size = 536150, upload-time = "2026-09-29T00:44:54.421Z" }, + { url = "https://files.pythonhosted.org/packages/ea/5e/7c4bc267e3cd4b8bd288de9f62d61fff203829c9cc649ea2aa12e9218cf0/librt-0.16.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5cd5b092441053364af968ea12084692cb9d4a22f3ce9524e377880bf028761e", size = 514316, upload-time = "2026-09-29T00:44:55.998Z" }, + { url = "https://files.pythonhosted.org/packages/e0/75/c8bc6b50f43c73819334233f5a3259c81216742cef56d2140c3dd377c3f0/librt-0.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ddeb3c9dedb461bb457c6c7d9aa7fbf35329da313d1a7543d00c8d0f3473c96", size = 557731, upload-time = "2026-09-29T00:44:57.581Z" }, + { url = "https://files.pythonhosted.org/packages/93/fb/e241f91bc8de6c7ac1c6a20ea6dd381bc52312b44d711ffcd97140db1e57/librt-0.16.0-cp311-cp311-win32.whl", hash = "sha256:e05108e0849966f53a8d2d3112a7af881d0efaa479bc735bba91108f9f2350a7", size = 104922, upload-time = "2026-09-29T00:44:59.078Z" }, + { url = "https://files.pythonhosted.org/packages/d1/38/c892383d2bb1a6a80b2ec8ede84970a265a792c56614a06282bf3008517c/librt-0.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:5f49cff01bd608ef7d97104cb035c75455e79c2d70bf4a506cf773338ac1860d", size = 125093, upload-time = "2026-09-29T00:49:01.621Z" }, + { url = "https://files.pythonhosted.org/packages/e4/56/8bbde1ed0b21480163617648f638fdaec9374cf5e9c846ebcee34ec02a42/librt-0.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:1d28ae980ae2218f9c5b95d191e947296f918c9bf0b400d467a9430275bbe678", size = 115910, upload-time = "2026-09-29T00:52:40.131Z" }, + { url = "https://files.pythonhosted.org/packages/ad/76/bbdaeb87b7c47b5c7343e90222b9bfa4e4a8a83f647e02933ad0129225b1/librt-0.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe52bf4641069e7978a14253b036cb9002def1926317e710f2e249f8a8c47742", size = 151028, upload-time = "2026-09-29T00:52:41.508Z" }, + { url = "https://files.pythonhosted.org/packages/fd/0c/ab8ed3dab0085931aec4a792c7eaac8dc6c5ff4691fda3a5360d9d8a9cd2/librt-0.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5bcc2c4726ced915b00de0c9856a4eeabfb3fddb93e10e0b8f735b7709358b6d", size = 155283, upload-time = "2026-09-29T00:52:42.873Z" }, + { url = "https://files.pythonhosted.org/packages/eb/36/494e79d460c80c1f030661e8287c9eca5e1ad652dc2b2180b6cd42abce0a/librt-0.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff7baa55f8e7c69851419e50a666015d02a74198716fd45c0125a2112e0a389f", size = 503185, upload-time = "2026-09-29T00:52:44.638Z" }, + { url = "https://files.pythonhosted.org/packages/9b/34/a8464038dd9db6e4381fa2b6eb73dc9a50888d77102c4c139304ac35cddc/librt-0.16.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:b95d5d92ab83d39e760a52091bb1baba664f3a2351e39b1e16801e5747c2f0e9", size = 496738, upload-time = "2026-09-29T00:52:46.441Z" }, + { url = "https://files.pythonhosted.org/packages/6a/53/e0e5e334ef0c6ed27039d323819368b9ef6712be87d55ee2bf9799398afd/librt-0.16.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b6d085d70bce51d43c5c7c36d63490770180d8779e71c49305c87b4213918de7", size = 513818, upload-time = "2026-09-29T00:52:48.068Z" }, + { url = "https://files.pythonhosted.org/packages/ad/f7/7ce72cbf19d0addd05090b339152fd0548a02562c2866a603e6e3b3da2df/librt-0.16.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:36e53948e99bbe3ffea257124cfcae1cfb01831555c9a9c903c9f9a72db7fd07", size = 531952, upload-time = "2026-09-29T00:52:49.816Z" }, + { url = "https://files.pythonhosted.org/packages/83/22/0b1bcb6a8e723c8b4fd60dfc8ae8ec6461c54073fbc8685efeb8d900d407/librt-0.16.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:54d11f726aae9df5a6ffbbf0a03a52449bbac84a53ef03669cb41cdfd4ae41bf", size = 524465, upload-time = "2026-09-29T00:52:51.354Z" }, + { url = "https://files.pythonhosted.org/packages/64/2e/e9c23b8b9df1813da1be205deca9606beb7ddd033972246cd426d05374a0/librt-0.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4323193ac0cd025f85af531df8ba91bf24d1973b401697347a6282e8fd3fcf5e", size = 543191, upload-time = "2026-09-29T00:52:53.284Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e5/6a8b21b342c03ed7e230fa3afbfd2edc58e6e87ef1f0d11fa2b9a748c252/librt-0.16.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e42f8e098b9c5396fefa05fb1cc7e33b0e08fc51da106b5de4a45fd22aac6743", size = 546979, upload-time = "2026-09-29T00:52:54.932Z" }, + { url = "https://files.pythonhosted.org/packages/84/9e/b5129023eced1be01e01c22757f53be551d463b1bb7264f787927404c1d6/librt-0.16.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:39ec1d5a14e37baf1450a6cabf03fe552340808bf1ad9d71824ab90117716459", size = 555317, upload-time = "2026-09-29T00:52:56.869Z" }, + { url = "https://files.pythonhosted.org/packages/71/89/28bba5938c725fe91f06bf93f7fa6c6b150229df53a87b454b0d5c2a796e/librt-0.16.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d1aabe3925cbb4a08d15b7b20ba4011b53019da0c4173a25155139b7b1baed65", size = 535846, upload-time = "2026-09-29T00:52:58.475Z" }, + { url = "https://files.pythonhosted.org/packages/22/92/63773026614f888c5d4e370e395ce42ca604b89f70b3acdfedbf94851b80/librt-0.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:300c3ffdc459f4a779a8411ecb188e3ac0b1ff3a3a7b099642555dedae06c69b", size = 573700, upload-time = "2026-09-29T00:53:00.127Z" }, + { url = "https://files.pythonhosted.org/packages/66/8f/347d4677eefb57cd9f8e01d95a1dcee9a91b4e44e664173c32ff6f3752e5/librt-0.16.0-cp312-cp312-win32.whl", hash = "sha256:c17194318e4c0c0348b36f36c2ec7534436fe0a4c15582403162a4f08c80797a", size = 106158, upload-time = "2026-09-29T00:53:02.031Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2c/5193dc81127cd5ddfad031391b046bf32dda219b38463ab872407ca30646/librt-0.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:25a58a19ea8d83b68209f04912df765e9260635ef77646542ed4b4abe6bc7940", size = 126176, upload-time = "2026-09-29T00:53:03.445Z" }, + { url = "https://files.pythonhosted.org/packages/ff/3d/9668a400c8dd81d162eba38b33fa49fa6205f1a64493570a13fbb815c3ee/librt-0.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7be7cf555bc30ec12622e9447299cc4a9b8ff307548b634794353db0c2065dc", size = 116572, upload-time = "2026-09-29T00:53:04.815Z" }, + { url = "https://files.pythonhosted.org/packages/46/cd/ae5e0e9dba45d1399aa04a5395bcc0bead40d9fa06dc903634a7b4d7473d/librt-0.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c5e6144e68b577f157519f2ba88ca20e3ed61c29b00e5cdfa76cd2d45acf059a", size = 151036, upload-time = "2026-09-29T00:53:06.284Z" }, + { url = "https://files.pythonhosted.org/packages/41/5a/48a16e323c5f9447a94cce7b59babf60fa04e62c3365ecf060c77ed8b320/librt-0.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:33f41443a1f4e1f099331b3d8120e409fbff84b9760bc1cc9ea496f37ddaa5cc", size = 155211, upload-time = "2026-09-29T00:53:07.72Z" }, + { url = "https://files.pythonhosted.org/packages/3f/29/0f59299eb4251a409b2e690ad4b7d9f8a676db829d7817ec961f32b44f7e/librt-0.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e510b7770bee609617a3374a96548eb114cae048023e3f049ee449e7ff2db32", size = 502587, upload-time = "2026-09-29T00:53:09.191Z" }, + { url = "https://files.pythonhosted.org/packages/de/ba/d6fb4ef8d1537c396079d72289f16be7cd35a366e5065c51253fea2760b6/librt-0.16.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:efc49c462d4516b8a58b00b490078fa64689fd1fe66970cc190131d7afb8027e", size = 496146, upload-time = "2026-09-29T00:53:11.016Z" }, + { url = "https://files.pythonhosted.org/packages/52/fc/8c50dd4d7cc97c0ee8f252c8a3104980f234391cf1519b554e8b9de08b60/librt-0.16.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:92caf82ebef5e12d21c72242b70d1e92536f1711cf2a727a4c276de4b4469087", size = 513336, upload-time = "2026-09-29T00:53:12.655Z" }, + { url = "https://files.pythonhosted.org/packages/a9/59/16c409c56f708eda2db9a0553662845d45e3871c77d70a240dae3f3bdc56/librt-0.16.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17bac7f7a16b328fff77e440287693eb017abde913595b5827ebccbc21ecd8a6", size = 531689, upload-time = "2026-09-29T00:53:14.39Z" }, + { url = "https://files.pythonhosted.org/packages/88/82/d34772a6c29d1446dcca6e64d74062efd508523ab351aa16625a4689d5cc/librt-0.16.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5b976054553670829985ed767feb78fb6bcede0175327c4844dd5c281c1be659", size = 524537, upload-time = "2026-09-29T00:53:16.064Z" }, + { url = "https://files.pythonhosted.org/packages/77/8f/24c5631313746131ccee53bc91fdc8374f9cf25e0082a1fee9c93bb98acc/librt-0.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0058f9d68721094105917254c72ac0569117bb7b13b9769cf45d26d89f9d21cd", size = 543231, upload-time = "2026-09-29T00:53:17.939Z" }, + { url = "https://files.pythonhosted.org/packages/f2/cb/5f8e0d41dbd8b499c2265e939c31acc9ba59845565bf99539ad1c06aebcf/librt-0.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:30b7beaf3f4487b7d8adef1f158b49067cb4d5a19fa7a3bf31a4e7a820e435c5", size = 546499, upload-time = "2026-09-29T00:53:19.666Z" }, + { url = "https://files.pythonhosted.org/packages/be/61/063052de441d1385f59cea4223f184bf9e5d125de1ae3239b490aa1e486e/librt-0.16.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:468df902df016a06eb0e40b0747dc8d14e47d7a38b18b63b1fb167d85cb94d63", size = 555261, upload-time = "2026-09-29T00:53:21.292Z" }, + { url = "https://files.pythonhosted.org/packages/14/11/a2ada0529372268d6401afa9d457a095b68cd7753532b6f7f33049a19b43/librt-0.16.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:aea7b1f2b125dad5de85f049136651bff256c883c65e6b9209b2da0a1ac3cdef", size = 536029, upload-time = "2026-09-29T00:53:23.07Z" }, + { url = "https://files.pythonhosted.org/packages/23/9d/5bb6d38853382986dca702fc7e06c8256d30f5fa0676d882773b744610dc/librt-0.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a8afb6557920860b7a3a596eb804cf37e09e7cf8a803db2478c202acc72d8c2e", size = 573748, upload-time = "2026-09-29T00:53:24.696Z" }, + { url = "https://files.pythonhosted.org/packages/99/f6/0025cde35ff7f607684dc775a2b2d732cce2561cec050a6ee1fb2e1fc6fe/librt-0.16.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:77c7a2b4fe2c1369e0d5aa1cade26740a7b14be32fbc9a5535d617d20065c39d", size = 79861, upload-time = "2026-09-29T00:53:26.089Z" }, + { url = "https://files.pythonhosted.org/packages/93/93/303b8592909bd583f83f02818ffbea3f7647ca1e22b1cd5465d04b8145fe/librt-0.16.0-cp313-cp313-win32.whl", hash = "sha256:02d89c813d5ff74b17df72d3a34819d132cd168e56b81bf755b809bd9e46b8c4", size = 106236, upload-time = "2026-09-29T00:53:27.43Z" }, + { url = "https://files.pythonhosted.org/packages/cf/24/80bbb463c60ed18e29cb26aba386ddb76609580e4e7160710e550587018c/librt-0.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:14ed6ebe3e4f85f326d7920011ad30ff49ed9334e62cf88caef9ba973d9e3a92", size = 126180, upload-time = "2026-09-29T00:53:28.7Z" }, + { url = "https://files.pythonhosted.org/packages/43/80/b1a6fbdd7da825cdd55c71aa81eb6cfa82c513c360774152eacb50b4a771/librt-0.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:83d4041a3d9b2fd053a8a4e1f22878b3e5833e2712956382d5c048d791454e91", size = 116557, upload-time = "2026-09-29T00:53:30.012Z" }, + { url = "https://files.pythonhosted.org/packages/1e/93/9e0cf7da129a93c3dc7f45bc3cd4a660f2aaa995aa8a6f95c2583ef41239/librt-0.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:931a0bb0fcac88f263e269e46eb30ba8e21402cd3c62ca40cb97034c0693fab1", size = 149844, upload-time = "2026-09-29T00:53:31.391Z" }, + { url = "https://files.pythonhosted.org/packages/8f/26/8a90d2a8f2b2e471bb486b7aec117b8ae622715ed6c39853aec48ea20073/librt-0.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1bc17e54e5305f8d40b7ca203671ff5a9e59c1d0f8ea0f625dcca53a3984de11", size = 154111, upload-time = "2026-09-29T00:53:32.718Z" }, + { url = "https://files.pythonhosted.org/packages/35/ce/67abb46258da4d3e42ff5b141db6f38c59357bef84c7979f183b22f924f1/librt-0.16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:877698bf6bca5721d8be345f2fe09778e40ecadea8b58c73075f2b1a53666bf2", size = 494234, upload-time = "2026-09-29T00:53:34.466Z" }, + { url = "https://files.pythonhosted.org/packages/12/f9/ea7162414a16f8f1bbd3b493ad6d22b926c5471916e078350bdbca8c4e5f/librt-0.16.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5981c011b306781ce561e18e14230a14524a3d8109b97553666c942c18f31a96", size = 491173, upload-time = "2026-09-29T00:53:36.124Z" }, + { url = "https://files.pythonhosted.org/packages/b1/09/9b3e869060dd33f9989b80ba4fea306f6db8cecefcdfe6d7346ef0603f65/librt-0.16.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:afced3dfc17cd805ecf7a3d77996a71cf5f2c75aa66eb0c21a9930f4fc992f86", size = 505547, upload-time = "2026-09-29T00:53:37.686Z" }, + { url = "https://files.pythonhosted.org/packages/50/07/79007d2165f649ea93e08c0962d1d62c70af9cde77965255095bf9d96f9a/librt-0.16.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca8052401c55d7511dda6760719fda7618067e83535d7d0010096d216c34b667", size = 523057, upload-time = "2026-09-29T00:53:39.301Z" }, + { url = "https://files.pythonhosted.org/packages/61/0c/8fbaff66d0ba376d8864653f5acce1569bae27e89648671f26f7eca67ab8/librt-0.16.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1e511762a074005bb0aa569166779834e75e438370226930d0ce1866d4b6a33b", size = 515158, upload-time = "2026-09-29T00:53:41.012Z" }, + { url = "https://files.pythonhosted.org/packages/df/2e/23ff0dece76f07a4124413a57682efa0bbeb5765ac0122bc0955513f82ca/librt-0.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f1e8591bd8a5a628cd7f07954c6a1592359a878bf032957a8e9057a41d644311", size = 534183, upload-time = "2026-09-29T00:53:42.451Z" }, + { url = "https://files.pythonhosted.org/packages/26/c4/e11dea21d9a29486eba78887380374189d472734fa32cc50cb37ca44d3d0/librt-0.16.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4aaefb4ba6c07e1aeebb2795c8958148f1d6f9af3b555b53d23d766edb6d67a", size = 540663, upload-time = "2026-09-29T00:53:44.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/75/e873ae158a8b7f5359be33e7fd6c1fbe02d9a78a3e89a77de6b0e837f476/librt-0.16.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:d92db7a0f6aee44f1baee94750457e8d2d1c6ccea41842de6268d34e8dc7eddd", size = 545908, upload-time = "2026-09-29T00:53:45.812Z" }, + { url = "https://files.pythonhosted.org/packages/ba/36/8939d3f6a93e11bd9592e6fe28d2b44f1c2dc4bed6e22e72359a91e18ffb/librt-0.16.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:378dfaffb38e59c24a87cde5713cd865d51ff7383fa12947f3907f306ea1ca55", size = 523302, upload-time = "2026-09-29T00:53:47.596Z" }, + { url = "https://files.pythonhosted.org/packages/71/14/35309f44a077f0f42ade0e2e7cd88c0cea760c661af205c01ea90d3c0e1f/librt-0.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3e0c39bdc85370422e8b637be76eb1fd07d30967551b03e62267dd156f553152", size = 565911, upload-time = "2026-09-29T00:53:49.278Z" }, + { url = "https://files.pythonhosted.org/packages/78/0c/df6255b94967f3159ebc46f08d8e783c12da6ee269ddb74b2efed63c640c/librt-0.16.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:1b384b90ab79a7bc30b566895809a636e0666f21f3cf12b54823d025b7e83839", size = 79119, upload-time = "2026-09-29T00:53:50.938Z" }, + { url = "https://files.pythonhosted.org/packages/6b/44/d30d5a5461378c9d33f36736c6791c3b4c4ba4b1ffe0da7350aedcb2c9a0/librt-0.16.0-cp314-cp314-win32.whl", hash = "sha256:52327da75a94012e7f932f913d20d3876bed3c102be00e6c3e8600ff7bdd58a7", size = 100140, upload-time = "2026-09-29T00:53:52.205Z" }, + { url = "https://files.pythonhosted.org/packages/c2/98/769712f356a1e897df3581bb0c3100375d054a000de26099360ea65b5111/librt-0.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:3f0b8114c44b2ac06ff5dacd08e07e8e807ff4f46083f2a1602685122559be41", size = 120464, upload-time = "2026-09-29T00:53:53.495Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d3/ae2abccc8bdc8b063c1613a77686e17b74e9d3d60cfe6f12c63fa2821b9f/librt-0.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:8caf96a4ef8fb27d0ac0d1ad8337d26a240acd4a02fe4345d0a8f264753e8f99", size = 110889, upload-time = "2026-09-29T00:53:54.817Z" }, + { url = "https://files.pythonhosted.org/packages/e4/26/0737d4be058dd6376eade7dd8b380d4b869b6394cee929393a5a431c45bb/librt-0.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:953107e2f68d0f3512c48f898b0dbf0ce5cc52bba0f318d847c985dc555ee4cc", size = 159838, upload-time = "2026-09-29T00:53:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/01/96/9bc96531d7c620e9949af904470f02e3fa8f35129ab8e8f281c51eaa3788/librt-0.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad37d5b9abd49c9a655dcda7ea52a8a752884062ef1ee71ae17c2f2a0f81fe6a", size = 162018, upload-time = "2026-09-29T00:53:57.532Z" }, + { url = "https://files.pythonhosted.org/packages/0e/fa/b0289dcb186eb3f97221ba00da5f4bd3ba7fa5e99752d48aa8d336615334/librt-0.16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c4aa329c17bd1aaea4f6e89335d8ccd494b3a5830b6654462273e50e11023f0", size = 703983, upload-time = "2026-09-29T00:53:59.024Z" }, + { url = "https://files.pythonhosted.org/packages/d9/ab/05ebbbde7530fc5eeb58fbd1581522a9f64f132fa703c4c595eed6e14760/librt-0.16.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0ead24d2562a49473dddd9efef8581f020007eb0054389c3ee3ffad38b1ca4c9", size = 683847, upload-time = "2026-09-29T00:54:00.671Z" }, + { url = "https://files.pythonhosted.org/packages/a3/75/f52aeecd4dbadbddf80725ba7de126d8bd5d0eb66247eae17a81ed90dd4d/librt-0.16.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02118f56a9c36ddd07dfd9b919d9ecc117ba20a90987d56aa4c429fa34509188", size = 698045, upload-time = "2026-09-29T00:54:02.247Z" }, + { url = "https://files.pythonhosted.org/packages/e6/55/fa277a835cd6eb42380591ceb85f48c5b4d2b2d7e2cb9869e1e17d24d237/librt-0.16.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4e29522c62e28595ff7e324c6834ade51127707f0e255b18d1c1cf03d39c1048", size = 724640, upload-time = "2026-09-29T00:54:04.078Z" }, + { url = "https://files.pythonhosted.org/packages/25/e4/2cf64354f3fde8ebd591b3b48f96510bee24ac5f7d1e567adbbe210abdbd/librt-0.16.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ff4b2367926b69c6215635902cccb04048e73094e9862900d27cb2c6bbff143", size = 731748, upload-time = "2026-09-29T00:54:05.741Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c9/c180af3e94e01aa529fa93d7733fec2abc47f222345400cf21d5481d5f8a/librt-0.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c6f1b27bf1632a7e016af9f145f82be95e1edd7721a646505c21059257cb5a04", size = 754960, upload-time = "2026-09-29T00:54:07.38Z" }, + { url = "https://files.pythonhosted.org/packages/95/d6/01073aa78c58f356b10d9c57b3fe9abb143df338142bcd316df417b89db0/librt-0.16.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5696d7f52e7b37217cb3a8f92c744fe835942602fdd4c1a8bc4741d3bfdce15e", size = 747000, upload-time = "2026-09-29T00:54:09.06Z" }, + { url = "https://files.pythonhosted.org/packages/f7/d8/1de3783908658d697a8cfc00582f61299ffba7796d7260c112e4700b1109/librt-0.16.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:6072e92dd876ff6ceeb6cf371e35e51f479349837391341f479b08df4564242b", size = 749569, upload-time = "2026-09-29T00:54:10.702Z" }, + { url = "https://files.pythonhosted.org/packages/b7/32/e817f66c96d6caa8bb8435ff93c4c220624d59efc506be59ab98fcd01d0c/librt-0.16.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:39ca4f2f2fe05de8e63493da592d84311adabe5bef52b193851981da9816b302", size = 729483, upload-time = "2026-09-29T00:54:12.25Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c9/23992ccd2b9d22798fdd0f61353183a47414e651da782ad83eb680f50833/librt-0.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9807485a908f00355820f18e91e045ffdcdc5adb68aaec40a1e2b88c5f7bba1", size = 776584, upload-time = "2026-09-29T00:54:13.837Z" }, + { url = "https://files.pythonhosted.org/packages/67/3b/e8af957f08e6e2e8e566b099e43d2748418aa565df6ee1d9d3331209fdfe/librt-0.16.0-cp314-cp314t-win32.whl", hash = "sha256:94be5cb7bca4df6201f4183e9e4fa2086c655283d20b38cd84500a69057575a7", size = 104402, upload-time = "2026-09-29T00:54:15.568Z" }, + { url = "https://files.pythonhosted.org/packages/ca/1c/946e6443d7cd32347a086043395e421e52fd603c9163d2ec970ceab8eed6/librt-0.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d46ca272b251d033dd4527b0dec5f261a28a52bd5fa0f99c117b0a1f8588cc2d", size = 126227, upload-time = "2026-09-29T00:54:17.165Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a3/bc4f9959d3c62bcbf9e5fd3470a8bbd8bf33224ed4c25d7fba173201b8ac/librt-0.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b9d6d4b14e92d876f8026b54c20c445f36425214c1081dc76f74e40db386b82b", size = 116493, upload-time = "2026-09-29T00:54:18.567Z" }, + { url = "https://files.pythonhosted.org/packages/b6/4b/10fdb42dfab4c1533e1570e686b18e86ff4328b406361b39fb3016667638/librt-0.16.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:6fe436af2eaf630474f491af5d032cbe45f93fcff5c3b9fe4ab194a7255b20ff", size = 149829, upload-time = "2026-09-29T00:54:19.933Z" }, + { url = "https://files.pythonhosted.org/packages/8e/30/a90ca13f1d3d91af1680000a4038536907018fbd51764767287a05d28b8b/librt-0.16.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:8ff5d26c529336be9bd7ae04483235d77778ee7d6444a95353102b542601ce81", size = 154522, upload-time = "2026-09-29T00:54:21.306Z" }, + { url = "https://files.pythonhosted.org/packages/5c/dd/bcf364eacfa070bb1fc88d503111ae7177914197ba1fa717c748926e7930/librt-0.16.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:909d8e3c1faee44cb762b1c519ff8613dcc5ceae5c99987a00917b5a31fd1d6a", size = 497593, upload-time = "2026-09-29T00:54:22.798Z" }, + { url = "https://files.pythonhosted.org/packages/18/c1/2c4e81e347bdabfe8346bfc6dc37ae5e154d61c88e30848ec0606025a5e0/librt-0.16.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:6d4a64283ee61824b5790de882bc68e2d9d7a5143537cb7a966f7354f71646d4", size = 480459, upload-time = "2026-09-29T00:54:24.364Z" }, + { url = "https://files.pythonhosted.org/packages/ab/d7/fef2a3cb8400701be496f6e459876f650b3451f407e30cb243de571ae615/librt-0.16.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5810ba811297fdf37a1531a57667cb8ace0842013ca8606bf9eb7c24cf4be154", size = 507814, upload-time = "2026-09-29T00:54:25.997Z" }, + { url = "https://files.pythonhosted.org/packages/e1/6f/53762927a32e9dc9eb1d1c1f3528da281290c86d96929a8af652f671266e/librt-0.16.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e56aaf8c167548dc8e5d6f3bd0f48dcdd299a23c73be3f744aab79d99e9c7f5d", size = 525114, upload-time = "2026-09-29T00:54:27.747Z" }, + { url = "https://files.pythonhosted.org/packages/6c/67/0b9d031f303c4e8c691a9a8ef9d272f13b530c11cc563b819df621b6a348/librt-0.16.0-cp315-cp315-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8f36c58e33b304b525c6c9c5076399c6ebf1109e17b9051a05a407b091b9215b", size = 520465, upload-time = "2026-09-29T00:54:29.331Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d5/2056a3a85864e882eb17a203a10ddb26fa748bc9718ec67e79059ab46cae/librt-0.16.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:242e00b3d4fa37c3d3c1ca5f5c9adb7d909ddb1eac9c41f2787320d00caa0af2", size = 537257, upload-time = "2026-09-29T00:54:30.915Z" }, + { url = "https://files.pythonhosted.org/packages/54/57/e0d79790c163cbc0909e209a6f62e30bb713b647f905a176cdc64848fd4d/librt-0.16.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:0253721561787b8df8443eb347b7a6461015354e5bdd37ee38a41fef220d2bb0", size = 527442, upload-time = "2026-09-29T00:54:32.478Z" }, + { url = "https://files.pythonhosted.org/packages/aa/50/1c0c95aba7af51f4752ea34fbf2eb79b36e7cae3a72536248e8c735de735/librt-0.16.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:3e483a8d69ede8067db70c0e83007423b6925de6fd53afed01d66160f2e9398c", size = 548139, upload-time = "2026-09-29T00:54:34.183Z" }, + { url = "https://files.pythonhosted.org/packages/98/91/a8a43dd5138d4f55f88846b8f0c85454a4fad69952cebfcff9948f831290/librt-0.16.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:69ba927445cfaaffb4081003ef5224c55a5c2ab67ef956f416ef744916e44121", size = 529708, upload-time = "2026-09-29T00:54:35.761Z" }, + { url = "https://files.pythonhosted.org/packages/2d/41/d5226881ab2b7c20d9d587b37bdd4a0ec8775a96d00ca87ac9f385587db4/librt-0.16.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:d6a365f2ab45a984d0e00eee0dd17f599ceab8cadab6ea07b6111c8132fc0e42", size = 567781, upload-time = "2026-09-29T00:54:37.409Z" }, + { url = "https://files.pythonhosted.org/packages/bb/bf/2345ba57a626e8c78c4ddcc724636a8df5a593fe46c1ee76bbf477e32b0d/librt-0.16.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:f01f3805f2dae4781c0c34b440e31740d082950bdaf89a6f601ad589a28af57a", size = 79177, upload-time = "2026-09-29T00:54:38.792Z" }, + { url = "https://files.pythonhosted.org/packages/1e/40/99e77936cc9207f629b077bf7cbc5e2f0827cddd7c29792f04ef881bd2c3/librt-0.16.0-cp315-cp315-win32.whl", hash = "sha256:b0e3e721c75d2e79a76d4422c79d7ba705fe1bbafec907037fe7a657a480a0e3", size = 100127, upload-time = "2026-09-29T00:54:40.251Z" }, + { url = "https://files.pythonhosted.org/packages/56/1e/801fe26bc622061b9dfd010e166d94142cb774b733217e6d98d1c0cf2638/librt-0.16.0-cp315-cp315-win_amd64.whl", hash = "sha256:bc02954b1295de798bbdb0b4e2d8a28c2117de8b5c73dcbeb27dc32572dfb971", size = 120480, upload-time = "2026-09-29T00:54:41.722Z" }, + { url = "https://files.pythonhosted.org/packages/bb/a9/d533983055bd36e112627384c2c038845d1df882540b8bcefb566475640b/librt-0.16.0-cp315-cp315-win_arm64.whl", hash = "sha256:c5db585d43449a5f54303d4b2774e45e1babd975cfe1630a3d708c0b80c3e560", size = 110915, upload-time = "2026-09-29T00:54:43.052Z" }, + { url = "https://files.pythonhosted.org/packages/55/fe/d62238fa9c653b0e0613290349467cb65711b5800e8e474f45e942a0ad95/librt-0.16.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f06c689cb14afd9b612727553a5ec5a40febf113ca41c4413a2b0b334285884b", size = 159714, upload-time = "2026-09-29T00:54:44.497Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ac/f31efe7818700be72ba4f9af8a80fa67c39808c8d26dacc55dc1f6f35172/librt-0.16.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:13b4e8aba90b0b1c82474e9844aa9ffe7ad3faa484350e1da64cb8188d903134", size = 162086, upload-time = "2026-09-29T00:54:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/d9/16/4d7487bf86a9d7e8e18f37ba5538789233ea693637379b75701bd35ec9de/librt-0.16.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a269c46ae327d8e6f8c1f85f7516cb52c0fa48127565a1105a4f4a05ff2a0b4", size = 712727, upload-time = "2026-09-29T00:54:47.486Z" }, + { url = "https://files.pythonhosted.org/packages/77/74/50cd550ccc1a517b9ed62347625c01ddf8c4afad66490312677c011458f6/librt-0.16.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a33e0dae1f8592146a4764d54ce842b278732d21a84e17c3bbe6b1bc158a2248", size = 681106, upload-time = "2026-09-29T00:54:49.126Z" }, + { url = "https://files.pythonhosted.org/packages/df/5d/7293f712975ee6fdd2251411fd9ef1c62bc99c7b83ecbe62dbc999b1fab7/librt-0.16.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:47ada6ea32636492c61aa8ad27ae3b9404bfe7a97e3ba946d1984236cc741da0", size = 705921, upload-time = "2026-09-29T00:54:50.905Z" }, + { url = "https://files.pythonhosted.org/packages/67/f7/8aab946f11d59d1bece9ffc65d994b200c789a8ca5a95c17e17e609f912a/librt-0.16.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43bd6e642d8a248c114327f98dd25ac5a7cb5aa168ef02f0559b91874df16b8", size = 731786, upload-time = "2026-09-29T00:54:52.584Z" }, + { url = "https://files.pythonhosted.org/packages/43/76/1c42ab31e7cb8384ebf6d3af607213c495222474f4940443ae7639ab7685/librt-0.16.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c3d1bb7841a816ace6449bb26d3f9560dbfa20e71c568d23f0f62bf1e68f50b1", size = 744964, upload-time = "2026-09-29T00:54:54.217Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2e/4b19982d933d2dfced671e840b219e4c1cd3f507df6e6dabb51bbd4e3850/librt-0.16.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:3931f7a3db322e7f44e02a280e3949326ce9579ad388ee8d691dc7c76da9fb70", size = 765305, upload-time = "2026-09-29T00:54:55.815Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1b/e872583de2dcb3ac7746e7a2321aeeb168274f3952a87dc66e05ddb29faf/librt-0.16.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:f4462528b6000afe8f16907b5c7c2553abf1df005ba5140e6eb394541c3624c3", size = 744959, upload-time = "2026-09-29T00:54:57.532Z" }, + { url = "https://files.pythonhosted.org/packages/10/de/a18c6bcfb297af2674233e90b3c3661c3a0af0f1434a0c966d2ef708a835/librt-0.16.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:80039ba9b6a7d5f1a0175a4cca6bbefead87bd854c80abad1cb30afe47a830db", size = 758138, upload-time = "2026-09-29T00:54:59.484Z" }, + { url = "https://files.pythonhosted.org/packages/22/1c/0df1d732539c297bb1a093e1fe3204d2faf76a9022cf4e1d1c2fce059790/librt-0.16.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:7a1d272724b581bb6bc769dfdafed6da2ecc9886ba2450311de55a4ac2e1e9cd", size = 744268, upload-time = "2026-09-29T00:55:01.179Z" }, + { url = "https://files.pythonhosted.org/packages/a2/f7/ccaf31331f20c91a5bd9bd48ffc3f743f9c81bb5720cc7b2a720ca204f0a/librt-0.16.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:fbe4fb8c5445f7496d7f7f6bb0807875d09d47e6771ffa175fb2df2895fb86ba", size = 785783, upload-time = "2026-09-29T00:55:02.938Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ea/7421d9e6db894cd6cd788b604b3394a163ded6b942052b6f96c23ccf08e1/librt-0.16.0-cp315-cp315t-win32.whl", hash = "sha256:375bfe6b572a8f6cfc398709356046173bf27e64c4c5edaf5f7062f051fb4bf9", size = 104355, upload-time = "2026-09-29T00:55:04.533Z" }, + { url = "https://files.pythonhosted.org/packages/85/6d/7c31a506eb847bc58aeb2402d58e17605e821f68ab5df5e66fe274a6df41/librt-0.16.0-cp315-cp315t-win_amd64.whl", hash = "sha256:bd3150023d3dc2bc70f3784e59ffa1140d56ddba3d8125b3d6f9f85221279bfc", size = 126134, upload-time = "2026-09-29T00:55:06.017Z" }, + { url = "https://files.pythonhosted.org/packages/36/69/7a5d10ac409c4da0355e054a14371871da9b5557fcc42772cd00181c6cce/librt-0.16.0-cp315-cp315t-win_arm64.whl", hash = "sha256:8ceafb70f2a4f0826f11031942e59c0728fd98da112dc346d4352bde1e486866", size = 116391, upload-time = "2026-09-29T00:55:07.484Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "more-itertools" +version = "11.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/b8/c63995bebbb9ac9c059350e0fb8c82c2420c85aeca7d34e40aecf3df9281/more_itertools-11.2.1.tar.gz", hash = "sha256:cbf08fd0af284dc69718b9b76a8e6203df624d70209ea511e4219d350c856f63", size = 154133, upload-time = "2026-10-14T18:50:30.407Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/57/3c4b1c6f2e0cc29ba023802458ea3d2a996f87085559e4a5f2192d549532/more_itertools-11.2.1-py3-none-any.whl", hash = "sha256:35a7377edd1dd6608dcb2cdf534ded55ea32d49448875ad042cd3f879fb1ded0", size = 74405, upload-time = "2026-10-14T18:50:29.116Z" }, +] + +[[package]] +name = "msgpack" +version = "1.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/52/1ec7ead2c7528bf3d1db73e886fa4df10f9e6f0eb7854a448b7090cfcef7/msgpack-1.2.4.tar.gz", hash = "sha256:475c44e12f2a5de766a8448783f149c9b33f3f49b88953c6cd739a77d93c732c", size = 197764, upload-time = "2026-10-26T17:55:48.593Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/cb/a3bd4d234c0f2f7e646b9be259b801c5d6a35c97f93dded4f722e6b80acd/msgpack-1.2.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1095b1ebcc8c9d3e70c51240b7160d8e9da66044e0a45c3ef8403d3a9ef0c5ad", size = 90935, upload-time = "2026-10-26T17:53:46.588Z" }, + { url = "https://files.pythonhosted.org/packages/56/3c/fc87d06bdfc99b302f4379f0eb34bb8695b6ecd90b965652d0a3195d1acd/msgpack-1.2.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a4b47ec7422bef149223786a87df80067ac65bfc7c0565e5cf1dfbdc40acee50", size = 90187, upload-time = "2026-10-26T17:53:48.151Z" }, + { url = "https://files.pythonhosted.org/packages/05/a3/abebe12c1b589b7eeab60cb87dd5eb398fcf549bdafca8c30d8d73e48493/msgpack-1.2.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c75cfda0d3ccb1f6abc20e0608ad6b226e11f317b5ac297721504d2509e2bd9", size = 466911, upload-time = "2026-10-26T17:53:49.536Z" }, + { url = "https://files.pythonhosted.org/packages/03/41/ed5517a107628f6f7f3a1f46f19de3aca979bd1fc95861cb56ce0e4bcc02/msgpack-1.2.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a45ceb5f199d5e388f28b550ba881096a3740d4bda10e661d77f59d9a2e8187a", size = 480247, upload-time = "2026-10-26T17:53:51.211Z" }, + { url = "https://files.pythonhosted.org/packages/31/71/14c39858380e11408fcf75aeab1cda0afb253cd8f62a01fbe4ae1838b66f/msgpack-1.2.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ca62b31a873c70b73f367bb2c1efec1d143016642c5191405549578184ff6ff", size = 438298, upload-time = "2026-10-26T17:53:52.919Z" }, + { url = "https://files.pythonhosted.org/packages/3b/73/ba40b91632e011851e1a397d53e0bd031848751902424a5b37c33f7de412/msgpack-1.2.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f641971d3eec89ffca57fa36d151ad1cf1b6a214b47faca16cb165c7d45ef8be", size = 461600, upload-time = "2026-10-26T17:53:54.8Z" }, + { url = "https://files.pythonhosted.org/packages/51/f0/c13ce7e7a7d8dabc1a48eecf61eb789084dbcc64374a7f19770eaf96f2c3/msgpack-1.2.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:b9eff629190a4b118549b654df32a56ed535351819f690d0c935d185500cc90b", size = 435020, upload-time = "2026-10-26T17:53:56.433Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d2/2a4e254f8ee5d5dd5019bd9f99164d79704788dbe16d9d6de77fda4e6727/msgpack-1.2.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4e22c6571ab6ac9036da87d8a6fddb4baf86981844b480c0c60a4a4be417ee48", size = 479138, upload-time = "2026-10-26T17:53:57.918Z" }, + { url = "https://files.pythonhosted.org/packages/70/b6/28f7eb3f38e3b6ea1f87f36c44cc25ab0eeb451147b5ff61637ce3d0b839/msgpack-1.2.4-cp311-cp311-win32.whl", hash = "sha256:5d7d4d2a5fc6a604f20c546ee1e8327bed1e9329be2417cef9af1f799f3e55e0", size = 67926, upload-time = "2026-10-26T17:53:59.172Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9e/67a97d5caa41bcbdbb4fae7bf5009b60222c72d0748364ac9e32de334a4e/msgpack-1.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:9db832747bd05834530189e564a3fe31e2617547dc1f3a005f835eafc2b8e048", size = 76117, upload-time = "2026-10-26T17:54:00.403Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/890b028b2cdb6b75fd56bd9388466c9fea9f10a31ebb685c489c5cb32fa9/msgpack-1.2.4-cp311-cp311-win_arm64.whl", hash = "sha256:deb1730c4c0c1a8c975be2f43efea6ee4834d35031a39075f78917d0ba8b3c04", size = 72632, upload-time = "2026-10-26T17:54:01.798Z" }, + { url = "https://files.pythonhosted.org/packages/27/fd/45f6cd13cefbb659a8e0128ea64d51b349571163fec3c9c20f99792dc42a/msgpack-1.2.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:90cba4996b18ec1201fcaabd01ec48ff4b9755416bcd52105ded2f89fe145c49", size = 91903, upload-time = "2026-10-26T17:54:03.097Z" }, + { url = "https://files.pythonhosted.org/packages/7f/89/169c2a0b1ffeafe68a4f13d8d96b6ed1cd8d40d8262b3a6690851da7eda1/msgpack-1.2.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:112933726919f4239646cca9572e2c2fa5626358c670da8440aac09403100a48", size = 90573, upload-time = "2026-10-26T17:54:04.383Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8e/272a384f2a001cfced1baab0a8abdd912d6281432670f4609d1aab718d7b/msgpack-1.2.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ca1e78106675f2aed07dc37b842ce19be70010ab22c5c5c04688f0840d48539", size = 461057, upload-time = "2026-10-26T17:54:05.821Z" }, + { url = "https://files.pythonhosted.org/packages/1e/d9/f59bd841fc2fd2b74dc50ce85860a6a25f58e588dd48946aeaf2862cf990/msgpack-1.2.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c4d5bbdbea8f5669b3a734d6c226772804fb120848f99cbe63a0ddee63b049c9", size = 475652, upload-time = "2026-10-26T17:54:07.414Z" }, + { url = "https://files.pythonhosted.org/packages/00/03/afd000e1b1e28fd535dc8c7bc21ebb88923bc1964a2429fe660fb313ace3/msgpack-1.2.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0d9ff7f3aaffd84010f1c501b05406a497584f5cab2f732eb9d89bf960e12f6f", size = 427082, upload-time = "2026-10-26T17:54:09.1Z" }, + { url = "https://files.pythonhosted.org/packages/f7/7a/e2890b272883c496faad777324ddb70e9cc4a6c63731962a4a39a6a40f44/msgpack-1.2.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aa10dc04c03408f31948ac1896a942141fd8d7a954b3612edac79f19663e4076", size = 451956, upload-time = "2026-10-26T17:54:10.476Z" }, + { url = "https://files.pythonhosted.org/packages/c2/46/0c1b240b8a580af3e72139c33b018025440a1a42c2579e82e39b1195ee36/msgpack-1.2.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:472a25463678f2795143a7cb42e88a1b59cc2375e9881917e69a9323bde42114", size = 423833, upload-time = "2026-10-26T17:54:12.195Z" }, + { url = "https://files.pythonhosted.org/packages/80/8e/851415b1a9264e6abf64d8a9617d856769d59e247fb9470106f133aedbae/msgpack-1.2.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cbb8a677da3e845713925e9a203b8a120b1e9da9989836890ba4a4a187902701", size = 470951, upload-time = "2026-10-26T17:54:13.764Z" }, + { url = "https://files.pythonhosted.org/packages/c9/74/d75bf61aab9cb88b84f7d3a8eca8dd92e19a742b77ded300a1177e88d031/msgpack-1.2.4-cp312-cp312-win32.whl", hash = "sha256:2b0b7dff5beddc10f16ecea6b28c6b98014d1135d7015bd83adff5037f35848d", size = 68786, upload-time = "2026-10-26T17:54:15.049Z" }, + { url = "https://files.pythonhosted.org/packages/81/c5/dd0e78eb04f9a0773a810d25ef2cd8f16bb941487567d0c63f814881133c/msgpack-1.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:6e38b123681df22373d545520f54bbeddc4706d9235a1161061f12bd6648497d", size = 77272, upload-time = "2026-10-26T17:54:16.491Z" }, + { url = "https://files.pythonhosted.org/packages/65/e7/b38f63ae82777c0077daa56c4b09af39d29dcb8927ab2ff59268094069c5/msgpack-1.2.4-cp312-cp312-win_arm64.whl", hash = "sha256:6795c588b210b2f13d62c8fcc23bf779b509b839ec5c197a7ab4f5191459e126", size = 71884, upload-time = "2026-10-26T17:54:17.995Z" }, + { url = "https://files.pythonhosted.org/packages/2d/26/16eaad5fe6e199334fa5bd66070778665717c86e9a273525dc706ddb06a7/msgpack-1.2.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:fb811ac3d463a75013b234d2aae56b9f0bdb0105caf4dd2ee65305b6a8a6078d", size = 92057, upload-time = "2026-10-26T17:54:19.616Z" }, + { url = "https://files.pythonhosted.org/packages/9c/b8/9660be6d120820bc05106f291e824c73d35f4ab77d927788ae67ea80889c/msgpack-1.2.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:36258fd0909e1bf26e94604439108846432abe4ffa9a23c9dc2f6f1c60f94b60", size = 90542, upload-time = "2026-10-26T17:54:20.965Z" }, + { url = "https://files.pythonhosted.org/packages/6c/10/cd55a69fec29df26884b178dc4b1803442ec82abf929604aac619881917a/msgpack-1.2.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9c5ba0f053a7e98f013f083c9d1b2dffb26cad8c897c533d8286e44ed24c669", size = 455798, upload-time = "2026-10-26T17:54:22.434Z" }, + { url = "https://files.pythonhosted.org/packages/c9/94/562e0733593a780c70b0b18994f30c205149f7f9f4efbe3e9b00b88612c5/msgpack-1.2.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7fabd415c41e62006c6641fcdf5b3e866f581c4e11c58328c0d0f69584b9577d", size = 469262, upload-time = "2026-10-26T17:54:24.043Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/76d1a5c597e04e1d360b05573d150bdb4502f5a014e6e9cf089c9537c156/msgpack-1.2.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7433d340de45003db3ed909a642c9469b598d175530f7a707cbaba64287d27ce", size = 420789, upload-time = "2026-10-26T17:54:25.587Z" }, + { url = "https://files.pythonhosted.org/packages/8a/c6/b72b8d8022718380db459ced8ffbabc7570ad2d22c7f2fa659c872cb6734/msgpack-1.2.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccd6e4af5347eb9828147320449bcd30e3321f6397d4583ff16047485dd8be3d", size = 447068, upload-time = "2026-10-26T17:54:27.721Z" }, + { url = "https://files.pythonhosted.org/packages/cb/dc/f378ef1def4aa135e70325c09e22457f3203ae2a390a192e892267906f33/msgpack-1.2.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:23d1459a1d0b4c9f6629df072d592eb74424b3ed3656b69af507bc9023cc027f", size = 418896, upload-time = "2026-10-26T17:54:29.325Z" }, + { url = "https://files.pythonhosted.org/packages/62/93/a7e507378f43e91415cb6fda47e0ded0c9de1618a1f4ac4f2887912a92dd/msgpack-1.2.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9e73761fe9fc55a4e9d2df8e8f59b0979231af4dbf80b8bf90cd64c74173d779", size = 465764, upload-time = "2026-10-26T17:54:30.719Z" }, + { url = "https://files.pythonhosted.org/packages/60/76/7f39f49cbcdaa4aafe64b4941b2640772dbdc1cac3a9332f4c9ba6994da9/msgpack-1.2.4-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:d088d1f552e129859db830692268747aba0a1ee3e6e0fe6344dbb3aab1df9f6c", size = 53615, upload-time = "2026-10-26T17:54:32.213Z" }, + { url = "https://files.pythonhosted.org/packages/67/9b/85b93350dbd7b52b358882f7f17a88a03664a7a59a359406e6315c162634/msgpack-1.2.4-cp313-cp313-win32.whl", hash = "sha256:892d4f17d7962bfd2c2928b0a47542bf2948f074a7c04721b73d4138b70481e4", size = 68724, upload-time = "2026-10-26T17:54:33.484Z" }, + { url = "https://files.pythonhosted.org/packages/02/4a/a7e2778ce09a943c17b6f91c7acb2f9488357657c01f2cccb278297621c4/msgpack-1.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:318d4e634d2b320be10decd9968ad1ae0be1d80cba23b5528c37b429eeb0e3e0", size = 77039, upload-time = "2026-10-26T17:54:35.016Z" }, + { url = "https://files.pythonhosted.org/packages/64/16/9ff7495a9853e9d7de74965fdadce15017e7213ce564bb5dafc5403c9108/msgpack-1.2.4-cp313-cp313-win_arm64.whl", hash = "sha256:bec3e34749b90cfcf116149aad11295c720ff4a74a7d0a35abdb968a396c1524", size = 71873, upload-time = "2026-10-26T17:54:36.19Z" }, + { url = "https://files.pythonhosted.org/packages/86/34/747f9ea2b428088201c73fcb3a885cebcbedcd71def0f1f3c36896294b27/msgpack-1.2.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:895e9369185df4a874768849405c30cba7990caceb3fcb1692ebe62bb050f55e", size = 92449, upload-time = "2026-10-26T17:54:37.503Z" }, + { url = "https://files.pythonhosted.org/packages/83/7e/52d208cb1561f869762c17be0e2c004e4d34f2842d239a450492d6246d62/msgpack-1.2.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c97f5f17407e1761f23f1944be33cbf1d5ce67017db32544dcd5e16e0b1b4a3b", size = 91202, upload-time = "2026-10-26T17:54:38.797Z" }, + { url = "https://files.pythonhosted.org/packages/2e/58/5516cabb60da83506024015c669622a0277979aef51eb611308cebaf4cc9/msgpack-1.2.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2444a4e04f924630d059ae6eae8f91fdfcd28ed9fd17b21bacf4e74550a091f7", size = 455185, upload-time = "2026-10-26T17:54:40.213Z" }, + { url = "https://files.pythonhosted.org/packages/39/8f/bf975b5d2111e4954a0f8567fc6b60bab22c8766dd4fa509af1334c91a4f/msgpack-1.2.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5d65b791ce4283e02b6267742ad540899155e1b32887b9cbdda47f38f5a076b5", size = 465078, upload-time = "2026-10-26T17:54:41.971Z" }, + { url = "https://files.pythonhosted.org/packages/32/2f/c74baeafc53d1c1fadfbeb774444d0e6354778d12b40b827e437a7a35856/msgpack-1.2.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5e4c67dbac05dce90a3fa1d845137617383c415e6b319062baac9734540706ae", size = 420144, upload-time = "2026-10-26T17:54:44.994Z" }, + { url = "https://files.pythonhosted.org/packages/b0/f2/bdf2ce9e284821397dc5549101824c7607ee6ba6e0635390d168a77ac49c/msgpack-1.2.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:781e856db4f2cb398e4992e2a74305295d3ebf694eec26fa0f4bc766eb9fa0a0", size = 446479, upload-time = "2026-10-26T17:54:46.484Z" }, + { url = "https://files.pythonhosted.org/packages/76/8d/b4572d24bb75d98bcbbd031a934a3a1d03494ea88a100cd51ab16c4c7d57/msgpack-1.2.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cfc1cc237792f9a5664002b66acb961027d4184528ec9d10e0e42330f7972383", size = 418780, upload-time = "2026-10-26T17:54:48.04Z" }, + { url = "https://files.pythonhosted.org/packages/55/8e/4493bef4422730cfd3420b84094652fabd27ef8aadc8b443a8995b524d08/msgpack-1.2.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f60de6ae13d4d2a12a483f15c5e47cb6fa2731aa32d92fb31178e2017d6574a8", size = 462009, upload-time = "2026-10-26T17:54:49.433Z" }, + { url = "https://files.pythonhosted.org/packages/41/29/efdc3d1d09e4e0e45955b0aad559b4c1f5d908767c9fb1021990c52182a5/msgpack-1.2.4-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:06a0657a4110d563255006b7cb7147432f67827144e429c2cdb1c967548d1817", size = 53714, upload-time = "2026-10-26T17:54:50.753Z" }, + { url = "https://files.pythonhosted.org/packages/df/0b/08794c65e0a752acf20aa44e193e61dfb552b48fe6c27ba6023c146f9e77/msgpack-1.2.4-cp314-cp314-win32.whl", hash = "sha256:727a65b35db9f5ef516fc0229c4b05cab983092b1ae274a8a769b2d517fb0499", size = 70726, upload-time = "2026-10-26T17:54:52.397Z" }, + { url = "https://files.pythonhosted.org/packages/b5/da/e2cc63ec61e7ac05595b391cba01c10cb4657f4e517da1512e4a75d2d12e/msgpack-1.2.4-cp314-cp314-win_amd64.whl", hash = "sha256:80f5d4fda1ba373d95933f98e6c1d18247feffac839fda3930bdd85e6561bb5f", size = 78346, upload-time = "2026-10-26T17:54:54.662Z" }, + { url = "https://files.pythonhosted.org/packages/93/e4/1b0eb49887009dc2c530171d659cf2aa37202b5f79c0b784e63777554b37/msgpack-1.2.4-cp314-cp314-win_arm64.whl", hash = "sha256:e5f67f0286f2ba2c6dbb4998404ed880112ca204ceda729cf239879cd89d3acf", size = 74152, upload-time = "2026-10-26T17:54:55.915Z" }, + { url = "https://files.pythonhosted.org/packages/d0/4a/6defc8fd0270c4ba675e6625f4f76ce936fd0c48733395fd7ba912cd423e/msgpack-1.2.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:45506bfb902cde24a0d33fb0581f58497ddb2682686dd1f6aa07e7b769df7ca4", size = 94083, upload-time = "2026-10-26T17:54:57.108Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e8/59f7e076739048864710a4de3403ae1c1b43ed5077b796cd9e8cbce9b3f6/msgpack-1.2.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:dc9dc681958e69f46b9f37def3e7fd6cc5dcfaa5943fb00bfe9c223a1a1052f6", size = 95037, upload-time = "2026-10-26T17:54:58.489Z" }, + { url = "https://files.pythonhosted.org/packages/2c/dd/dbae250b23b831cd0571eb664089f80de3249a39e98c6ef55f9a0efe928d/msgpack-1.2.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0bef691e2a95119cc6bf3ded29325dbd89c4b6f8ff233070431948ed70902421", size = 472722, upload-time = "2026-10-26T17:54:59.924Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e2/383ece1c1b27c1ed322055fce8ab8972bc6d529ede881592065ce0c461bf/msgpack-1.2.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:55e6106d2d085af42b2de72efeb38ed255241a24b32295ca889707c1d679c442", size = 468726, upload-time = "2026-10-26T17:55:01.492Z" }, + { url = "https://files.pythonhosted.org/packages/37/2f/5410a8815ae74a824ac87543c612e40cb6674851b70a6ad858bb32813203/msgpack-1.2.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:996dfc4774c240c8e6adf1166ae102141cfbed33c8856fde821bd6c0bd35ee41", size = 420488, upload-time = "2026-10-26T17:55:02.848Z" }, + { url = "https://files.pythonhosted.org/packages/39/8e/16fdf02b4f91dff9c1480433c1bf80756c2fedc0b74fc6a231f02dfed007/msgpack-1.2.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:efa1357fb0c7201e833de28638be371ee127476f7ccff9e7a94211b0afc33ddf", size = 455541, upload-time = "2026-10-26T17:55:04.564Z" }, + { url = "https://files.pythonhosted.org/packages/c4/76/2454ef54d780a167667552d02e7bc977a3d419943bcbdf6a96a4da6786ad/msgpack-1.2.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:b9270b63409e70c8c6deb5faedc81fc27c6bd0196b38084a8773f68286abf034", size = 419514, upload-time = "2026-10-26T17:55:06.257Z" }, + { url = "https://files.pythonhosted.org/packages/ac/8b/2af9bf378def33c24875f250421b0d0b1b06f72a1c2c3f964749fc4cdee1/msgpack-1.2.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2b597bb01aff61d65e305c2cf2589c93c86609929d42d575bfc359f3c54ea8e1", size = 461910, upload-time = "2026-10-26T17:55:08.05Z" }, + { url = "https://files.pythonhosted.org/packages/0e/46/a133ac6c4cef4d3939383c00cc19baa16ee85fd70af0c5990e7a9ca8767f/msgpack-1.2.4-cp314-cp314t-win32.whl", hash = "sha256:ad5bc540cbc34db236f8535721a9a872d12a9d88d1322470f1fc7c5e9dadfdb2", size = 76441, upload-time = "2026-10-26T17:55:09.711Z" }, + { url = "https://files.pythonhosted.org/packages/d4/f5/8d22ec454c188f1795107a3fd9f68ada485076ebf394a4aaaa5fbb6093e7/msgpack-1.2.4-cp314-cp314t-win_amd64.whl", hash = "sha256:287e52c2ebaa94f8eca045628374859f51584e77bc07086e6835a9bb2204c774", size = 84321, upload-time = "2026-10-26T17:55:10.947Z" }, + { url = "https://files.pythonhosted.org/packages/41/52/1390514aee47d14ca3fe6ea0cf236fddc55021867ace30daf8761deba36f/msgpack-1.2.4-cp314-cp314t-win_arm64.whl", hash = "sha256:f3f19fe5decd348b35b003ae5f32d3fa90877413a0183da676f748a3a7ab9270", size = 78589, upload-time = "2026-10-26T17:55:12.425Z" }, + { url = "https://files.pythonhosted.org/packages/d0/d8/0465d475c1a7063af1a1fb4f8c69e0dd661c4dd172055c9757a343a07d5d/msgpack-1.2.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:765584b93ed6f0b561f0c56e9735f24945c0682f857c9b3ee3b4caad9c32f66a", size = 92449, upload-time = "2026-10-26T17:55:13.665Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d0/5220a8a53579dda39f3526394ba5b7eafc28736085f2626deda7fcd22cd1/msgpack-1.2.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:0221748c30ace75fde0dec8c470abe65fb5374cd4f37adb9db6aca7a3c362c0a", size = 91209, upload-time = "2026-10-26T17:55:14.913Z" }, + { url = "https://files.pythonhosted.org/packages/b2/98/f151742eba413503074a10d8f636bf03dd4f3f7cba29689767a35d19bd1c/msgpack-1.2.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5917972ce1bf5f85f761031e00dab6fe0ad9f880cb3d2d43ed74b330c850400", size = 455713, upload-time = "2026-10-26T17:55:16.406Z" }, + { url = "https://files.pythonhosted.org/packages/b0/54/890510a2c9841aff63258e085d15d4e140c7eef559d4da81ef2d2d867436/msgpack-1.2.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7ae8cf6012372cecb43016132d1b87ccc2ebb8ae5ab5078687399e82423386a", size = 466177, upload-time = "2026-10-26T17:55:18.351Z" }, + { url = "https://files.pythonhosted.org/packages/3d/41/a6f20d7c2c380fb072b95ffc5b865a1d62eaf49d77fbee44466c45a1a8de/msgpack-1.2.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e78c66cf97ac5675037f705ca433ad98ac9177f9523e7fdbb34e486ae29044c8", size = 424398, upload-time = "2026-10-26T17:55:19.979Z" }, + { url = "https://files.pythonhosted.org/packages/89/86/fa9559961f2b0d498e6cefa226298ddee2b896cb223449c211702bc34071/msgpack-1.2.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:59887281c3c163a7afff7dffaaad2f78cd2b513b7e1a7843f1ee8e7cd6a94231", size = 445686, upload-time = "2026-10-26T17:55:21.775Z" }, + { url = "https://files.pythonhosted.org/packages/39/23/5a9d94036cdd77d4310bbb7cfaf3ccd1f087c4a5d5a4befec4361c5fc0dc/msgpack-1.2.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:9f46e70c8d22e96856967ab9d80c51dcf5bc63133e4da2d66fab64c0d4119b82", size = 422096, upload-time = "2026-10-26T17:55:24Z" }, + { url = "https://files.pythonhosted.org/packages/6e/4b/86a5384112509a94ff6e20028aba6845138743effb7c6617e959ad1256ab/msgpack-1.2.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:0a1fd6c31952155b7cd01061288c70303e6554ae855244dfb38a897fd94f8749", size = 463407, upload-time = "2026-10-26T17:55:26.146Z" }, + { url = "https://files.pythonhosted.org/packages/f4/cf/14db289e0ad531e22ce0f03284865f81d14fbc80bf3f79d3b1714bcf76cf/msgpack-1.2.4-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:b1f08ec826417e3c8dc3edadb50f38debba033af6cb849229f0eac72f80f2342", size = 53743, upload-time = "2026-10-26T17:55:27.497Z" }, + { url = "https://files.pythonhosted.org/packages/46/72/a76fc90b51503c0bdacbc7fc823aa6fa62d40596ac47f9ea8492d6f95a34/msgpack-1.2.4-cp315-cp315-win32.whl", hash = "sha256:e8ba23c838739fe929e868095171e71f2f38d6ce0fcf5840b576fb82648e58e6", size = 70780, upload-time = "2026-10-26T17:55:28.705Z" }, + { url = "https://files.pythonhosted.org/packages/58/a7/fa9d4a1b5dfead83ea6e03b4007041a5da988c25eb941d42612e0211d3c0/msgpack-1.2.4-cp315-cp315-win_amd64.whl", hash = "sha256:67310606cf2528a6dc3ece1298dcd5cc6c57add148b16d22c5111138aa84820c", size = 78288, upload-time = "2026-10-26T17:55:29.928Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f3/8163d7938a8fe003952fe2719ddb31da71998559bbe290c55ffe622b886b/msgpack-1.2.4-cp315-cp315-win_arm64.whl", hash = "sha256:ce76e7a7c11459157887a8dadf07c107ff74eca98cf914f0de6ee7ab4b47104d", size = 74235, upload-time = "2026-10-26T17:55:31.112Z" }, + { url = "https://files.pythonhosted.org/packages/b4/fa/37c3219b250d81bee788c0dd78ae2fc673db2da1c21ae51f7982d85698f7/msgpack-1.2.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:fb9ddbf23b8c6e89752af399fcf4daed60055e239cda44c6acfaa76d19331e8c", size = 93793, upload-time = "2026-10-26T17:55:32.304Z" }, + { url = "https://files.pythonhosted.org/packages/83/9f/b8afcd20d32cf4be1fa3c327e997656d6d446e667452b0fcc66b91710e82/msgpack-1.2.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:e283cf563166c21762131b88e3870ee2ec57757b08a8736929757b5a67541061", size = 94746, upload-time = "2026-10-26T17:55:33.624Z" }, + { url = "https://files.pythonhosted.org/packages/e6/4f/03348d381fcbbc2685356833408cc7e9d2af0fe0775926935a2889650f64/msgpack-1.2.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40e91bf8325f492e8eb3c3aa6de06b20593c225336bb52b585c913d7c1da025b", size = 468480, upload-time = "2026-10-26T17:55:34.991Z" }, + { url = "https://files.pythonhosted.org/packages/16/46/e54af8d9a51fb562e068e69a0d75a51e9c2fedec49f911f888515f5477ab/msgpack-1.2.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cfa86432bf329d6b976f5a00ad4c9064fd51736e4967a52526750236345cc2da", size = 470064, upload-time = "2026-10-26T17:55:36.615Z" }, + { url = "https://files.pythonhosted.org/packages/74/f5/8f9a6b3af1d803e832b11017c8dad44d761fefdb91dba04ee58cb51838da/msgpack-1.2.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:42e0a7dc26df739149478585d4264338b4d330f24b3e3b57d5aa89e48866e8ab", size = 421267, upload-time = "2026-10-26T17:55:38.076Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8f/7302b0d18eadbbfef9be1dbbdc49905f7f3b847200c3e47068d093976be4/msgpack-1.2.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:8e680367090a58c966052d61418cc943111863538fd82471d61fca5271d911e1", size = 451244, upload-time = "2026-10-26T17:55:39.639Z" }, + { url = "https://files.pythonhosted.org/packages/36/c6/05717fb56b510b5e974446f2cb8e9b26fa4347fafc0c5927745b176939b3/msgpack-1.2.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:a6c9926f8871b261622fe6b599db72c69be5bca8fdc0976886f9a531a301dee9", size = 420273, upload-time = "2026-10-26T17:55:41.488Z" }, + { url = "https://files.pythonhosted.org/packages/05/d9/a19077d664c37319097e16ba8de14e6b3a2edcc8ee78a2069c0808e38960/msgpack-1.2.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:c50bac325dbf1a9c80e10da6dbd1100d7082f6b12e153084501e18e86cd3a037", size = 460421, upload-time = "2026-10-26T17:55:43.223Z" }, + { url = "https://files.pythonhosted.org/packages/a2/bd/0e2033a7435f8d2311be37363fedc88bdfa9fd95c364ee8ac3216eb63e36/msgpack-1.2.4-cp315-cp315t-win32.whl", hash = "sha256:34051de19ae532ba47fcab5b0abd08c25c7a64ff763ad819f18764d45f3c2c81", size = 76256, upload-time = "2026-10-26T17:55:44.588Z" }, + { url = "https://files.pythonhosted.org/packages/b3/3f/aa7265f25dafb6af7567a1a7d0a95c5566803db2226c5e084dc5850cfd96/msgpack-1.2.4-cp315-cp315t-win_amd64.whl", hash = "sha256:6ad2f0808099d4281208ff2c756efa958a55a7c8eb21fe1c7052b95c584f02f1", size = 83939, upload-time = "2026-10-26T17:55:45.773Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f2/c53904c4bc3da828fb75678bf489ece808a277affa73f8a7a91dfb7c5851/msgpack-1.2.4-cp315-cp315t-win_arm64.whl", hash = "sha256:e38d854f1c60e94f46d998765201126338bde3fe1b029be0d849094bcbef72c2", size = 77995, upload-time = "2026-10-26T17:55:47.016Z" }, +] + +[[package]] +name = "mypy" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ast-serialize" }, + { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4a/3c/78ecece71ee4b5445389a4ccd11627cfb9c69e4de554d11060171f376305/mypy-2.4.1.tar.gz", hash = "sha256:63b590965691e540a335fa74dadf31a7069142f6b72e234689bbd244edf55623", size = 4066728, upload-time = "2026-10-28T19:23:13.286Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/8b/2bc7f489528db504221ad7eff6b3f83979ee57d066103c72a85d09046a30/mypy-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:79a1e79199e980fb41f219cb3d4746d25c64b0b623840d3ed57df1cdc13a6502", size = 14321495, upload-time = "2026-10-28T19:21:16.612Z" }, + { url = "https://files.pythonhosted.org/packages/18/9a/b2f037b4982dce33645296e4394b031ade60f697f468761fa3ea8e2f8ece/mypy-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e18d0da3898b3bcd16192f15a206e7b8b8dd0f4a0b3e51aa5bd5c2afe749e2c", size = 14467468, upload-time = "2026-10-28T19:22:10.629Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5a/379f9bfa18bf3f8d43668fbd9ae4f2922dd027a559c461ca9d41cde1d32e/mypy-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b69a15fc2e75858d6b15e91ed3a0dcff1a533265183b64734138791fe0f49aa5", size = 15421496, upload-time = "2026-10-28T19:22:48.005Z" }, + { url = "https://files.pythonhosted.org/packages/83/50/3bde18a2824ec296432cebe01752ccd0ab8a2ad784abe4390040d019b3bf/mypy-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:70971cc0bcb1d3f03d2eb68fa430a6481ccc03558dc001d9534d7e5fa274c392", size = 15670425, upload-time = "2026-10-28T19:21:57.026Z" }, + { url = "https://files.pythonhosted.org/packages/6a/36/8b722b88c325d317354de7d10d8fb9d4dc0f958433e873a91fc4ed21a06e/mypy-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:6f7225951a277dd0d6add900731d487174b7d24ac133c09d670ed63b4d8cb90d", size = 11300972, upload-time = "2026-10-28T19:21:48.724Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d6/fb2bab1245658d68af8abfe776362a780c621fe0f364f2c7b53039a945ee/mypy-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:be4c03f33c55500191df2ed4a9b5e7edbdd1fff067fe361a5a9b1b5d3262da6e", size = 10873349, upload-time = "2026-10-28T19:21:32.104Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1a/0be9dc6af5e0e04128f18a5e36b4ca44bfb0085857d37aa6a7de1ac2b0cb/mypy-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d63737426a048a27705a4eedb828669f4bc0873612a1b46b0b9fe892b2ebaaaf", size = 14381321, upload-time = "2026-10-28T19:21:54.223Z" }, + { url = "https://files.pythonhosted.org/packages/0d/a6/7907e36711a8a8c703f961f076fab61793383694140bd1fd87589f3f68d4/mypy-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7344869cad05f073b8cae2826774fa0161e3eb2f5c685b76813574008d77d750", size = 14466373, upload-time = "2026-10-28T19:22:25.211Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b8/7313212b29de570c25c9859d7c8e4ef2251a6d34338a1e20031d94297721/mypy-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a20ff6cd2af7a670c64f089bfa5fbcebe8ff3bf896c5e6ac7c9862c7960e4494", size = 15553666, upload-time = "2026-10-28T19:22:36.511Z" }, + { url = "https://files.pythonhosted.org/packages/23/8f/92966b6082ff49da9142e1e527eb9af4359a9a61632a1cfc313da96b37fe/mypy-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9ed1195502cca32be5ef756b1693477f4991db2f2e34eaa90cc4ad6bea4f9531", size = 15802641, upload-time = "2026-10-28T19:21:13.421Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b4/874f6fd54b005020ad63e2cf7a59b178d16a771d478849b29b842cb0cf14/mypy-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:4c194c5d878130fca1ae662dfb1feb6274afbab0b40032c80147377e0ea803d5", size = 11383067, upload-time = "2026-10-28T19:22:03.516Z" }, + { url = "https://files.pythonhosted.org/packages/b0/41/5ae8e6528c2faa96e4a921a999d2c7ac7c565bee184b4282bf62ffa76b5d/mypy-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:71eda06e5bae51976ce869fda429159c9cec678bd02f25bb197f0265c8f991be", size = 10946882, upload-time = "2026-10-28T19:21:39.51Z" }, + { url = "https://files.pythonhosted.org/packages/6a/65/cd19bc06b67d2df4828220245fd98569ba40fac00c60ba48bef1817d8ac3/mypy-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f1613bfe6726169a5680ec3dad5fe1f6d96285c12aded51ad432eadedd39d45", size = 14214179, upload-time = "2026-10-28T19:22:27.49Z" }, + { url = "https://files.pythonhosted.org/packages/c9/db/4d54ca4f49a0113d0c956980272aefdc6eec5458f7a72b350785b9ef2249/mypy-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:680ba5d9f0e3fe0c746b3d14df15f2a718e4bc308a1145616a1ea691ce7c354b", size = 14376217, upload-time = "2026-10-28T19:21:08.019Z" }, + { url = "https://files.pythonhosted.org/packages/a2/45/089b4724b85f0f408941be5298f817ee89181c1ce031a73d60ebb150c2c7/mypy-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb70621535c22fd4b1a0450d37ed1d6c5eb39656a1cebfb189084c12de54ba7", size = 15467623, upload-time = "2026-10-28T19:21:21.555Z" }, + { url = "https://files.pythonhosted.org/packages/27/4c/15edbc64b0b1412bfe94c74192b3b56554ab642b85a31bb06cef6313101f/mypy-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4af5ad558033bf71a44a1be149ed61633522824f84c1b6bc2445d3fe2d2a5296", size = 15729867, upload-time = "2026-10-28T19:21:37.557Z" }, + { url = "https://files.pythonhosted.org/packages/76/5b/7d160fb685994b65b0ca86d352f3afb5424f96a9e6914719f7b861fb6701/mypy-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:acdd82cb3a2eb10720e87706a128d75785d005a8c47e36a4973221524f41fc56", size = 11390802, upload-time = "2026-10-28T19:22:18.081Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ea/453d27f8d531f57c5f14aa73094eaa48e3fb77f680bdede2045cb64fa58b/mypy-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:133886ef1a7a8cf673df55d865e41580c6c46aa9b8e31e1325dfe315c038f745", size = 10950427, upload-time = "2026-10-28T19:22:59.003Z" }, + { url = "https://files.pythonhosted.org/packages/7d/75/282d43d6fea7be984ac63e75ffd8eee146ba2f3b077bb1ca5bf3f973e0c4/mypy-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c45485061ba08f700acc12cfc8b177e6997e6bc353605babfc0abb081e079456", size = 14233251, upload-time = "2026-10-28T19:22:44.977Z" }, + { url = "https://files.pythonhosted.org/packages/ac/a8/9021263cc7e761451c7d8131bdfab3c0a5c2d67aa2d694670019e1ab86a7/mypy-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727890a32f1858c09549eb55a8b234fe990d460450b28f03e8213ef925f1247c", size = 14394953, upload-time = "2026-10-28T19:21:29.492Z" }, + { url = "https://files.pythonhosted.org/packages/16/10/4192a5cea09ebbc41c534f57bd0d8f0fb42a8e810632cda6e37f072c59fd/mypy-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:beb254fec368c4e7f7f82a5f310c6470b893ec88a90b66426da971c6826b0453", size = 15442824, upload-time = "2026-10-28T19:22:42.068Z" }, + { url = "https://files.pythonhosted.org/packages/99/e6/d3b0a7474aa4f696594a47a218b6796d9c4346fc81ed288904278cddd9bd/mypy-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ec416d5d2ae689e681f5727e328723f18d8b5dc8c903a146b7851dc5727aad8a", size = 15717227, upload-time = "2026-10-28T19:22:54.026Z" }, + { url = "https://files.pythonhosted.org/packages/48/6a/2ec530dacd4f77ca50d0fa05b854098f2d75e5d18c587d2612b44f10d68c/mypy-2.4.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:0e95ad0bec03ced9a73b42514208abd24c789e67f0e1eba476e276dd7a2dea3a", size = 7898637, upload-time = "2026-10-28T19:21:41.709Z" }, + { url = "https://files.pythonhosted.org/packages/cc/56/de9d7bad12e3868d5f1f4279aed20b1b568b2c5e166f2d3a05b211dca0b1/mypy-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:51f742d4154824837ca6e92aa81f00eec222700a3c337bd258e5562a3880d75a", size = 11576656, upload-time = "2026-10-28T19:22:13.232Z" }, + { url = "https://files.pythonhosted.org/packages/b8/12/4fa9883b9b59e5c96ff62845ad019dc47786031c45d67eaccf452cffffd8/mypy-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:f44dd4c5ab22df21206dd926c98381ebdbf5bfd696df37dd38ded2d23143fcb6", size = 11174403, upload-time = "2026-10-28T19:23:01.346Z" }, + { url = "https://files.pythonhosted.org/packages/3f/f2/827e356fc4f74c60b8da42663336e035b49d948a3c11224b0fc7543086b1/mypy-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2875280687e64740e6ddcef43bd4c5852ad45ff34549740f6aea3f0373870b93", size = 15713427, upload-time = "2026-10-28T19:21:26.757Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fa/e58a4fcae1d238189eac758036c0921992a86e3e6209190efd96d61fc5d4/mypy-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ea0714d2bccaf6d010c970e1d3ba2c9c2add79d2030aad2ef03167d788948276", size = 15938481, upload-time = "2026-10-28T19:22:34.371Z" }, + { url = "https://files.pythonhosted.org/packages/a1/54/a20f881801b88900923f2be1541a4b438ad0f0883e03836641fdc3d7adf4/mypy-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c6ff0e7ea546943001a91639c9f0c64b60d239268fa5d29e4a6c87f82c2373", size = 17243006, upload-time = "2026-10-28T19:22:39.425Z" }, + { url = "https://files.pythonhosted.org/packages/de/1c/ff84a6133a6e89c390bff6b25d9bad6598e7891b205f4b30b496906d636d/mypy-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a5b5da107dc2c93fb0a22f7a45dbaea5dc131afc7056b5468d78e819f9a138e6", size = 17557728, upload-time = "2026-10-28T19:21:43.607Z" }, + { url = "https://files.pythonhosted.org/packages/15/4a/effa47d39b8fadf679c08e7c78559e523f9769a42a75662d2d15b2b9cdd6/mypy-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c3a4d0c47053cc90035dd3a2c321112b593ad42935d0cbfd747288e1564fa8ca", size = 12370826, upload-time = "2026-10-28T19:22:29.779Z" }, + { url = "https://files.pythonhosted.org/packages/46/9f/b214ececb1a97fbb61ab3dfd48ae3cffd92ae2c148af4c9dc94c6c56772b/mypy-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:0c5bf267645351887b72903fd2f5fbddcf85234e0e6c4ad94e2fcfb4f0c3f971", size = 11851083, upload-time = "2026-10-28T19:23:11.288Z" }, + { url = "https://files.pythonhosted.org/packages/57/5b/e44a2edb0b25a9f1429de770e1d0238af23302671dd40c77ac5efeb0c559/mypy-2.4.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:db599d03e7d60d15f2e0a11665c18bc52a88699fcab990fdf8cecd5be8ac801c", size = 14243144, upload-time = "2026-10-28T19:21:10.975Z" }, + { url = "https://files.pythonhosted.org/packages/59/d4/5c99dc3a28e11d2f0fcbb02df63d2d3e574dedc0f9f69d50901df305a7a6/mypy-2.4.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6c7210e40dd423af7d65cbe428b5906d11dc60659337bdae4e5fdf02ce32ed7", size = 14409316, upload-time = "2026-10-28T19:22:15.515Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c9/3108b38f4c30eabd80194f5d9771a87e27196c5e0ddb5bf4b99c6ed1e97e/mypy-2.4.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2d4a51db92059eecc2c33b2a5194b28585ebfd917292c015fe87a77dbff6cd2", size = 15445573, upload-time = "2026-10-28T19:22:05.635Z" }, + { url = "https://files.pythonhosted.org/packages/dd/12/84a53eceaf11c46dfd7931fb6b8902d01fb33787d3a991e81c461458150b/mypy-2.4.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:01b7718552d017f88d1151f3cc9d6556d778a90bd58060a2c3d87d070f9099fb", size = 15732989, upload-time = "2026-10-28T19:23:06.512Z" }, + { url = "https://files.pythonhosted.org/packages/65/ba/bf017dc2abdf83b2f74e29c43834b7af67dc1f1b20202f02dae60b4781a0/mypy-2.4.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:3467b1d13000812ab85dc2a3834b9379ec77798ca1bcabe434e23fb21fead692", size = 7898932, upload-time = "2026-10-28T19:21:59.366Z" }, + { url = "https://files.pythonhosted.org/packages/76/05/0c22b1f0390120a8592d31209cb6b9f932b6a0b426fe643e550de15139e3/mypy-2.4.1-cp315-cp315-win_amd64.whl", hash = "sha256:080cf64a60b90a73435542feecf4171904cc5710658165b40c6869115d4aa100", size = 11577577, upload-time = "2026-10-28T19:22:01.302Z" }, + { url = "https://files.pythonhosted.org/packages/73/fb/ac01e173629697ddac2f11e51efd10347d673f9a7311b03f4aba710ebccd/mypy-2.4.1-cp315-cp315-win_arm64.whl", hash = "sha256:f9118a3f50de264b614861bb11814833a742138ac3c8e2e49a860b6977fb2704", size = 11173540, upload-time = "2026-10-28T19:21:46.444Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e4/b9b9c8eb09e70927ee65b1456cfed35710b6e4ff0b07f364ceaf2202307c/mypy-2.4.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:9d7dafd56179d296651df9e1844b91c9517c379398f017a2a435d077a28943c1", size = 15706623, upload-time = "2026-10-28T19:22:20.528Z" }, + { url = "https://files.pythonhosted.org/packages/26/74/1ceb1ca884add0565e618d013dd24333039100dc0fcc42661561f2e1cae5/mypy-2.4.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d923cec43316f0e6736b8298fd00abeaaf348a091c20e7296b3aebceecb63eca", size = 15944095, upload-time = "2026-10-28T19:21:04.779Z" }, + { url = "https://files.pythonhosted.org/packages/2b/68/27bcf9b4efa22733b6050485ae37845b94c9b8851abe4fc60632d905c32d/mypy-2.4.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6e081b466e88d4343adffe11aff0f02df34b5b9070b4b700053a0b7294c0be1", size = 17223065, upload-time = "2026-10-28T19:23:03.724Z" }, + { url = "https://files.pythonhosted.org/packages/1a/a3/ed5724b317bf585c29f3c8be2792e97d45925d65a9c8af40ceeb267072e6/mypy-2.4.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:70196470ac300f444a302a738541101893c2c57804078b33690286a7899149e9", size = 17560589, upload-time = "2026-10-28T19:21:34.539Z" }, + { url = "https://files.pythonhosted.org/packages/42/2f/005185e6ab4752fd6cc2d1a6d1421fe21979770afe2490c00c555f34a913/mypy-2.4.1-cp315-cp315t-win_amd64.whl", hash = "sha256:de95648e0a6d46fa9929b956ed2c87c5dc9933d4d59945e6390e9d753c74e7c1", size = 12353324, upload-time = "2026-10-28T19:22:51.481Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d6/20420cc9c780087139662534d128c2f3274361f8bb7e9cf0d5495a846ed5/mypy-2.4.1-cp315-cp315t-win_arm64.whl", hash = "sha256:ef8d5be90032261197ac388d945d8ff4f476c95880798a1911760af64ddfe71f", size = 11845599, upload-time = "2026-10-28T19:22:23.136Z" }, + { url = "https://files.pythonhosted.org/packages/21/5c/6e8010f8f2c4ad817364592d4b3883633417269b913fc9d5174fdeb7e565/mypy-2.4.1-py3-none-any.whl", hash = "sha256:1784648d6ec8c2b5465e3f26241b845a0b3cb4e56c993c64abe16989e7698999", size = 2801286, upload-time = "2026-10-28T19:21:19.516Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/6f/43edf3be2748d0e40974a5ee046a8bb4c9961a4bdd3e7d5c6dcbf32d1af6/mypy_extensions-1.2.0.tar.gz", hash = "sha256:c6e275a07f1c2fc096b62940452d0eaa3f3af7de45d704787866240a7c6d5a51", size = 6566, upload-time = "2026-11-03T16:26:33.692Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/99/7b1adac7e97ce7bbda34792dc6e9b2f5cc5cffd1875883f78a818b2a2687/mypy_extensions-1.2.0-py3-none-any.whl", hash = "sha256:993e7a20aa5671eb41a7132cf555af30062da99729601601b9a8382b11cae768", size = 5114, upload-time = "2026-11-03T16:26:32.731Z" }, +] + +[[package]] +name = "nh3" +version = "0.3.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/2f/022b27146d52d24b1b353b003359134788ecbcd6fcdf6283adbd57c0fbc8/nh3-0.3.7.tar.gz", hash = "sha256:71860d01c16f4d8c72e334e0674beb2b0899dbd0bf760de18932ef4390303848", size = 25662, upload-time = "2026-08-23T14:26:30.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/88/b594f0e86856b37e182fb663283da419eea6424972506e640e890885467f/nh3-0.3.7-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:91a4dab4e94d9fc54b9f67b1adfb23e81fab7ab43f33c3b8c97be9aa38f789ba", size = 1471147, upload-time = "2026-08-23T14:25:55.259Z" }, + { url = "https://files.pythonhosted.org/packages/1e/60/847a21339f095c4d4c655af31fa2d18b174585bcc210709facacc7ce205c/nh3-0.3.7-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eae64328e46a25785535afcb6885b6f182ecaf5ee8c88f8c075422db8aacc65b", size = 820463, upload-time = "2026-08-23T14:25:56.803Z" }, + { url = "https://files.pythonhosted.org/packages/7b/7f/1a103e00aaf5e59f2dee4c2709aac609bb2d4bb74fddaf0dcfade11ed87b/nh3-0.3.7-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4968fe8d2db97c6f047659bf46a449fd8ec377f44ebf3e0a1b96c0d3a333ae32", size = 861456, upload-time = "2026-08-23T14:25:58.087Z" }, + { url = "https://files.pythonhosted.org/packages/d8/4a/e9c436089a0c80b928011ead0efd156aa7639a19b6064ef58dcedcab8369/nh3-0.3.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:be53a4825585f701955cb9baf49f478f56eb81e20294329fe4bc689dd5dd81fa", size = 1023930, upload-time = "2026-08-23T14:25:59.465Z" }, + { url = "https://files.pythonhosted.org/packages/04/5c/aa1468e3e281e78d2b3b7d762ccba59f681af355e971dbd255d5903f7b86/nh3-0.3.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:94fd6e59553fbb9ffd8ba71bbd5a54e3126ba01799a097ae30d5341d750bc6ac", size = 1102614, upload-time = "2026-08-23T14:26:00.869Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/57d186d9d3dd38905dc12dddb3484406cdf6aa0b1ce33639a2d277d4ee1c/nh3-0.3.7-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:18f4278ecd157d43cb35acd5aae9f35cfa79f546b4922bd86536adc0f6312102", size = 1059915, upload-time = "2026-08-23T14:26:02.388Z" }, + { url = "https://files.pythonhosted.org/packages/6b/53/097a5ad0b34b15d67a472ef849165a54209fa5fbd3e639801c6fe439ba28/nh3-0.3.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:808def0c8c07843e6e50dc84f532457bfa2cfd17417b219a5d9e7c773709331a", size = 1047402, upload-time = "2026-08-23T14:26:03.897Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/c57a2c70534418310889a65ccfac3525e62f0bc0a8613225903403755ce7/nh3-0.3.7-cp314-cp314t-win32.whl", hash = "sha256:874b7d67a067bd29a59223f6270fc30da4edd8e6d87fd219fc93bcbaa662c946", size = 619895, upload-time = "2026-08-23T14:26:05.105Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b7/efda1d0a611d940bdfde6893bde1ea6b7b7d48c31273aea48e35b822fd58/nh3-0.3.7-cp314-cp314t-win_amd64.whl", hash = "sha256:614dac4a4c36ad084e78447d16fe898dedd762e354a7ab9cda2984e82f67883d", size = 633456, upload-time = "2026-08-23T14:26:06.661Z" }, + { url = "https://files.pythonhosted.org/packages/1d/18/3ab564595cb88196f50d26e163ed0fd2acc731ab26ac615df91981885887/nh3-0.3.7-cp314-cp314t-win_arm64.whl", hash = "sha256:157ec1eb7a62f3d9a7badb8d82d89aa810e3e24e097eedfa481a25d0c8a99877", size = 611003, upload-time = "2026-08-23T14:26:07.813Z" }, + { url = "https://files.pythonhosted.org/packages/94/0d/c257754bf57f829f307aa226bbe136d3a1356b5a0d08324c7b6bd2a8aacd/nh3-0.3.7-cp38-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:6c3aa50eb26e9228238271db9f983cbc3b006dfbfeca2d4dc34c33ddc6ac5ea5", size = 1493959, upload-time = "2026-08-23T14:26:09.025Z" }, + { url = "https://files.pythonhosted.org/packages/07/42/a687e7091928806e514f89fa2666f25ec9bfe0a902fc4402b25e51ce408b/nh3-0.3.7-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f266d3f1b3647449923a8e406524632220dd5d8b647078dfe45b885d33d10479", size = 859615, upload-time = "2026-08-23T14:26:10.606Z" }, + { url = "https://files.pythonhosted.org/packages/85/05/b0e6bef633549a23347d5462aa288fcc42381e7918482062ca3cb456242a/nh3-0.3.7-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e8fd1ab205258b29254f72db377d99e2c96aa7653ef3b015ccab0420b094b506", size = 839872, upload-time = "2026-08-23T14:26:12.037Z" }, + { url = "https://files.pythonhosted.org/packages/17/40/2a0921d45b20828708bcb56887e47dcf8cae13818de5bf9a01308d348712/nh3-0.3.7-cp38-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:19f288c938ec6eef1f5d2c6cab47838e71fef8097e1c1233802be5a6230ba086", size = 1091325, upload-time = "2026-08-23T14:26:13.34Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d1/9d70e0e418a48280ec0ddc6c1b08b4b1136ebcc31a1625e57ff5c665fa51/nh3-0.3.7-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de2b2aab32ea303405debefdcfc58043d3e635fa3f67b9eb140d2b0e0c0d2563", size = 1042482, upload-time = "2026-08-23T14:26:14.667Z" }, + { url = "https://files.pythonhosted.org/packages/93/a7/02dd159d4e71f98607d8d4249cddb7561e77be1a8e4dec77d76e1b68fc99/nh3-0.3.7-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b7279d43323a25225df23576af6594a16693f61431170848b8b2ac21ad4f174", size = 946868, upload-time = "2026-08-23T14:26:16.094Z" }, + { url = "https://files.pythonhosted.org/packages/a6/ed/c5510c615dce55b6fcc364aa1838142f938beed64f5e4927490dfcaf4405/nh3-0.3.7-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70f5ac8626e899a4bab0ef74ca2f5bd602f49c7b739e6e5026b4afc6d63dac42", size = 832161, upload-time = "2026-08-23T14:26:17.272Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e3/3212c1a5b5745245d7f18885207bbddb34c56075f34dd682bd539aad55cc/nh3-0.3.7-cp38-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:5ffdfcb9a686ffb12765376bcfb6b5b55728516d3c0ee317d29982381ded3df8", size = 849791, upload-time = "2026-08-23T14:26:18.498Z" }, + { url = "https://files.pythonhosted.org/packages/20/64/9e36594efad6c290de4240d02cb2bd80c339a4ab1c4de66e599ffa6d9d81/nh3-0.3.7-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bc42bb1193c1e28a1e74c2cabaca178e118a7103e8832699fef8a2b3e2496493", size = 875473, upload-time = "2026-08-23T14:26:19.908Z" }, + { url = "https://files.pythonhosted.org/packages/00/0c/1a8985fd43fea5530c0ac890b6f0b423770ee72f111b70b7a77f2dec243a/nh3-0.3.7-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d56e76bd3cadb09b6b0cef364850811663734b348a25f5f587a2819c495367bd", size = 1036463, upload-time = "2026-08-23T14:26:21.536Z" }, + { url = "https://files.pythonhosted.org/packages/b2/5d/891e533b716cf00df76ad0ba6485dcfd14d59a6430a3cc99057c4c04004e/nh3-0.3.7-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:fd4a70efb45d5372174f718878eb7a35c12677626a63b2f103b23b833457dcac", size = 1116029, upload-time = "2026-08-23T14:26:22.907Z" }, + { url = "https://files.pythonhosted.org/packages/42/e5/ae8c0782fce74fb6fcf7234bb3d4017f37ce181b4f9d29369eab21c50a04/nh3-0.3.7-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:15f5fbf090f5c88d61c820e1fc1fceecb6520cca9fe85649c06b57ef9dc9ff62", size = 1076589, upload-time = "2026-08-23T14:26:24.302Z" }, + { url = "https://files.pythonhosted.org/packages/26/a4/c3423351e8d864ad756e85e15f0c01433361f14d34e4ed156482c0518f2a/nh3-0.3.7-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6698a822132beedab80f131c08d8d0ac5a178ddeb488d02ca4b67716ecfac7af", size = 1058871, upload-time = "2026-08-23T14:26:25.674Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6a/478f153f1d7c0baaa3d1e8bb5fdcee3a6235f90fe44ea969a9d4e2b8c47a/nh3-0.3.7-cp38-abi3-win32.whl", hash = "sha256:6e4280115d44c3b278eef712a86748c1a723105cd79feec46952383117ab4e59", size = 630729, upload-time = "2026-08-23T14:26:26.932Z" }, + { url = "https://files.pythonhosted.org/packages/b4/b9/34433ccb1f0fe6968dabbb7d4bf5721c6221878ef07832748c06655a6a80/nh3-0.3.7-cp38-abi3-win_amd64.whl", hash = "sha256:618e3059caf41ccdf5dcccb3fa9df4cf6e4efe23d1382a8bbfca272a8a4f8bfc", size = 644462, upload-time = "2026-08-23T14:26:28.294Z" }, + { url = "https://files.pythonhosted.org/packages/f9/70/e140dffff6e808dc6343598df76e7e2407fd0f581de3524c75fba2e0cf24/nh3-0.3.7-cp38-abi3-win_arm64.whl", hash = "sha256:f04b7d333b27f13ca439da3cf1c75c2fba34f104969f6ce4ac8e7079699c2f4a", size = 621867, upload-time = "2026-08-23T14:26:29.547Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/99/d27cfc9518f49e4cbc25c683ec7cf8704a9d31311341c291c0e78ddf791b/nodeenv-1.12.0.tar.gz", hash = "sha256:4ea7f88339310afebc3253f2c7a91b94bacf97d73a36a5c108962abdfaca501e", size = 131292, upload-time = "2026-10-31T19:03:18.847Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/6a/8a9ac7d5e2f7cf53c459bfef90ebc17a2f8cd54b665af96799d4c534840e/nodeenv-1.12.0-py3-none-any.whl", hash = "sha256:80644d65c10cc2be12e3e4b54b3367ff288c7ad24ae75c2dcc65454fc7449d4d", size = 39442, upload-time = "2026-10-31T19:03:17.427Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pathspec" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/886dc7c9d21e2d95aceb696f1e31271742033aeef3661f6e9c8921493592/platformdirs-4.14.3.tar.gz", hash = "sha256:021add1ab113483edbcd4694f5fbb2d688b893ea30d35e1155bb371cf4be0be8", size = 71124, upload-time = "2026-11-01T16:27:32.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/41/f0aa003909ee77a9e7e55f8659abb635ca23ab0d022a449bbb18da87a1ef/platformdirs-4.14.3-py3-none-any.whl", hash = "sha256:cba2d05fe5e18b26b1fa6f376b8e6234c012abe1f8696c486fface7d0054e931", size = 35276, upload-time = "2026-11-01T16:27:31.498Z" }, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, +] + +[[package]] +name = "pre-commit" +version = "4.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/c3/6965c2690ddce885ec75121572d065a5b94c5a5d8d3e657927ecda9fd715/pre_commit-4.7.0.tar.gz", hash = "sha256:1f3deee12b914c8fa184bd2b5953391c2e4f36763e403d4a23dc9983fa7c6e86", size = 198120, upload-time = "2026-10-12T20:45:40.32Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/83/ce0a196e4f7b20b11ce3aa1fc72fb973f64b7628d51c1b8aebad37fb7f81/pre_commit-4.7.0-py2.py3-none-any.whl", hash = "sha256:2e229038ad3656081b70c27913157e4b636ef306f643f024a8a8e3f0f7b2f877", size = 226261, upload-time = "2026-10-12T20:45:38.858Z" }, +] + +[[package]] +name = "pycparser" +version = "3.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/27/eeb9f307bf07060f3d9f9aa0fb8c15b01bdfded0a941e4b2719c7f94cacd/pycparser-3.12.tar.gz", hash = "sha256:f03387877eab82ce01bbdfd0ba7252ee55a90b1c708d5129e2ce915475cf1db6", size = 158785, upload-time = "2026-10-22T13:40:03.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/ae/315bbeee126a769cbde43cf4908acb4b40408d8bf8bbf334dd7368d8dadf/pycparser-3.12-py3-none-any.whl", hash = "sha256:a076f3f489b39b43ed13563a1dafe42447445bec2e294154ec5c57fcdda4c85e", size = 62600, upload-time = "2026-10-22T13:40:02.021Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pyproject-hooks" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/5d/f2ddeef4a855a102aaae5e97826a0260007522ab504421b75addfdb1517c/pyproject_hooks-1.3.3.tar.gz", hash = "sha256:defda19b854fa0d3bd4f76ea4ddcba8abd7dcfcdd585a6690ade050744fc5f43", size = 21013, upload-time = "2026-09-16T08:58:03.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/11/044d1ae1b4ec0d7af88ee5bc91e081be1022533032b906a7bdabdbb60977/pyproject_hooks-1.3.3-py3-none-any.whl", hash = "sha256:5fc53fdac9f7bd63fbcdc868fb5f90b4784d78a53a3d3388cd738b807441a20b", size = 10724, upload-time = "2026-09-16T08:58:02.96Z" }, +] + +[[package]] +name = "pytest" +version = "9.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, +] + +[[package]] +name = "pytest-cov" +version = "5.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/67/00efc8d11b630c56f15f4ad9c7f9223f1e5ec275aaae3fa9118c6a223ad2/pytest-cov-5.0.0.tar.gz", hash = "sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857", size = 63042, upload-time = "2024-03-24T20:16:34.856Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/3a/af5b4fa5961d9a1e6237b530eb87dd04aea6eb83da09d2a4073d81b54ccf/pytest_cov-5.0.0-py3-none-any.whl", hash = "sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652", size = 21990, upload-time = "2024-03-24T20:16:32.444Z" }, +] + +[[package]] +name = "python-box" +source = { editable = "." } + +[package.optional-dependencies] +all = [ + { name = "msgpack" }, + { name = "ruamel-yaml" }, + { name = "toml" }, +] +msgpack = [ + { name = "msgpack" }, +] +pyyaml = [ + { name = "pyyaml" }, +] +ruamel-yaml = [ + { name = "ruamel-yaml" }, +] +toml = [ + { name = "toml" }, +] +tomli = [ + { name = "tomli-w" }, +] +yaml = [ + { name = "ruamel-yaml" }, +] + +[package.dev-dependencies] +dev = [ + { name = "build" }, + { name = "coverage" }, + { name = "cython" }, + { name = "msgpack" }, + { name = "mypy" }, + { name = "pre-commit" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "ruamel-yaml" }, + { name = "ruff" }, + { name = "setuptools" }, + { name = "tomli-w" }, + { name = "toon-format" }, + { name = "twine" }, + { name = "types-pyyaml" }, + { name = "wheel" }, +] +test = [ + { name = "coverage" }, + { name = "msgpack" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "ruamel-yaml" }, + { name = "tomli-w" }, + { name = "toon-format" }, + { name = "types-pyyaml" }, +] + +[package.metadata] +requires-dist = [ + { name = "msgpack", marker = "extra == 'all'" }, + { name = "msgpack", marker = "extra == 'msgpack'" }, + { name = "pyyaml", marker = "extra == 'pyyaml'" }, + { name = "ruamel-yaml", marker = "extra == 'all'", specifier = ">=0.19.1" }, + { name = "ruamel-yaml", marker = "extra == 'ruamel-yaml'", specifier = ">=0.19.1" }, + { name = "ruamel-yaml", marker = "extra == 'yaml'", specifier = ">=0.19.1" }, + { name = "toml", marker = "extra == 'all'" }, + { name = "toml", marker = "extra == 'toml'" }, + { name = "tomli-w", marker = "extra == 'tomli'" }, +] +provides-extras = ["all", "yaml", "ruamel-yaml", "pyyaml", "tomli", "toml", "msgpack"] + +[package.metadata.requires-dev] +dev = [ + { name = "build", specifier = ">=1.2" }, + { name = "coverage", specifier = ">=7.6.9" }, + { name = "cython", specifier = ">=3.3.0" }, + { name = "msgpack", specifier = ">=1.0" }, + { name = "mypy", specifier = ">=1.0.1" }, + { name = "pre-commit", specifier = ">=2.21.0" }, + { name = "pytest", specifier = ">=7.1.3" }, + { name = "pytest-cov", specifier = "<6.0.0" }, + { name = "ruamel-yaml", specifier = ">=0.19.1" }, + { name = "ruff", specifier = ">=0.17.3" }, + { name = "setuptools", specifier = ">=77" }, + { name = "tomli-w", specifier = ">=1.0.0" }, + { name = "toon-format", git = "https://github.com/toon-format/toon-python.git" }, + { name = "twine", specifier = ">=5" }, + { name = "types-pyyaml", specifier = ">=6.0.3" }, + { name = "wheel", specifier = ">=0.34.2" }, +] +test = [ + { name = "coverage", specifier = ">=7.6.9" }, + { name = "msgpack", specifier = ">=1.0" }, + { name = "pytest", specifier = ">=7.1.3" }, + { name = "pytest-cov", specifier = "<6.0.0" }, + { name = "ruamel-yaml", specifier = ">=0.19.1" }, + { name = "tomli-w", specifier = ">=1.0.0" }, + { name = "toon-format", git = "https://github.com/toon-format/toon-python.git" }, + { name = "types-pyyaml", specifier = ">=6.0.3" }, +] + +[[package]] +name = "python-discovery" +version = "1.9.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ea/87/77b17c6d289a551d682826e228e3efa3199305a080541d991cb7b268a527/python_discovery-1.9.2.tar.gz", hash = "sha256:de397b9c4b09a5fb8bb4c51db3c0da71fb81d2283718d74fd1efaabffc32afbc", size = 140950, upload-time = "2026-11-03T05:04:25.117Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/5b/d61e08d34eeb74eb88431243e3849551f0161de08659d55312955afd2a36/python_discovery-1.9.2-py3-none-any.whl", hash = "sha256:65857e689ba72aeb5517e68b7025430ed60372b78d037245e0bed3d41ae7ba65", size = 44201, upload-time = "2026-11-03T05:04:23.777Z" }, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "readme-renderer" +version = "46.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "nh3" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/d7/9309494fad74ee831d4546f69325b5519f37c6dfb2d9ba495db8c6d4f4ca/readme_renderer-46.0.tar.gz", hash = "sha256:af3e964914f6310a33ff67b72a4bdd940bed8d7c3bdecd2d14f40edf284bfe90", size = 38382, upload-time = "2026-08-28T15:18:32.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/72/ac5ca81fe9121fcaa9d828d21017cba00a16a98e4ea5fb60c878f93dda4f/readme_renderer-46.0-py3-none-any.whl", hash = "sha256:d0dae1f74bb273b534770cb4cccb6bb78735540afdb03c2146f4e19dcd412560", size = 14239, upload-time = "2026-08-28T15:18:31.132Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "requests-toolbelt" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" }, +] + +[[package]] +name = "rfc3986" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/40/1520d68bfa07ab5a6f065a186815fb6610c86fe957bc065754e47f7b0840/rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c", size = 49026, upload-time = "2022-01-10T00:52:30.832Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", size = 31326, upload-time = "2022-01-10T00:52:29.594Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "ruamel-yaml" +version = "0.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/3b/ebda527b56beb90cb7652cb1c7e4f91f48649fbcd8d2eb2fb6e77cd3329b/ruamel_yaml-0.19.1.tar.gz", hash = "sha256:53eb66cd27849eff968ebf8f0bf61f46cdac2da1d1f3576dd4ccee9b25c31993", size = 142709, upload-time = "2026-01-02T16:50:31.84Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/0c/51f6841f1d84f404f92463fc2b1ba0da357ca1e3db6b7fbda26956c3b82a/ruamel_yaml-0.19.1-py3-none-any.whl", hash = "sha256:27592957fedf6e0b62f281e96effd28043345e0e66001f97683aa9a40c667c93", size = 118102, upload-time = "2026-01-02T16:50:29.201Z" }, +] + +[[package]] +name = "ruff" +version = "0.17.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/73/81f140c4edd9cc323de5478e6bbd3bbcfae9a82692df1a258de8cec6a6d2/ruff-0.17.3.tar.gz", hash = "sha256:a57049c8addb3662073859bb55a7ad35aa54f8a7c9ed268911d1333c5aadaaa9", size = 5339444, upload-time = "2026-10-27T00:34:05.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/8c/083365310c4e79c842f25bf5a842facbd9b0c0ec336f96dffa5074fe723d/ruff-0.17.3-py3-none-linux_armv6l.whl", hash = "sha256:ab86b84cd9d05e56d329742c0cabdcbe2d1d56c98f4a04aab9b5b66196febfb4", size = 10216522, upload-time = "2026-10-27T00:33:29.822Z" }, + { url = "https://files.pythonhosted.org/packages/72/26/4b2edf31cfebe9605d8f6ed8f1d6f376d3a53d4c9a123e62661c64c440f0/ruff-0.17.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e407b4a6852853a9a2cdce96963e94ad9775578bb44e7561a0f2829f3cc04b11", size = 10217786, upload-time = "2026-10-27T00:33:33.949Z" }, + { url = "https://files.pythonhosted.org/packages/a2/7e/537aba4b7f54397a374d2f6a6fc93e9c8015e18553f31a4a7b7dbced48b5/ruff-0.17.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b75cc113b3aca388933d8296b667b1ac401a80317ea3074c9b0a66541199da29", size = 9440362, upload-time = "2026-10-27T00:33:35.784Z" }, + { url = "https://files.pythonhosted.org/packages/3d/66/283e39734f66c8a5ebaa93c22eb7b7515779a0b1d5a5c0ad20e05c0edb41/ruff-0.17.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab5fa7ed5ce18554ea69d850ad162cbaa0c85fc47c08d83a569f806681c9a6ad", size = 10094281, upload-time = "2026-10-27T00:33:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/21/4c/1ffc768497bd025a32c72152771e40c0b99bddc5cc6e4f50c7949a395346/ruff-0.17.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c673c170e27834d1262e3a9c1e97bdc9b9c3b180c63d89173ce69747232474c1", size = 10022543, upload-time = "2026-10-27T00:33:40.181Z" }, + { url = "https://files.pythonhosted.org/packages/73/c3/f90db547301080fcb82c92abf914c8bd57b89911d9b65a6c4cc6b52d0635/ruff-0.17.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a754c0341bc9ca151b7b335988b3263921c08859f84ca219b70cee825571b6f", size = 10683921, upload-time = "2026-10-27T00:33:42.182Z" }, + { url = "https://files.pythonhosted.org/packages/e5/98/92d4a8a26c6c96cf1a5b34dd59036d8a71e52d650aab065c58867e964e63/ruff-0.17.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4590b9d86c0b1543ebb09094254e191cd43fe8edaf330baa035aab03da251532", size = 11373408, upload-time = "2026-10-27T00:33:44.19Z" }, + { url = "https://files.pythonhosted.org/packages/43/02/1f24d2e3064c9753926deeb901afa57777b37ee46799b09ddd7aee6e5145/ruff-0.17.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bbde18beccd98c29a227c63c99022e3443b99258e08326df6425dfe0443705ef", size = 10977469, upload-time = "2026-10-27T00:33:46.179Z" }, + { url = "https://files.pythonhosted.org/packages/f0/20/fecedea2209f574ab92033b344e01a7f0c2dc76c6d6d19a14c9f8141173f/ruff-0.17.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fa4b0f931cdbcb8a52044f370a3eb429fb42eb88807b0e800fcaa98dd42b24e", size = 10577491, upload-time = "2026-10-27T00:33:48.233Z" }, + { url = "https://files.pythonhosted.org/packages/33/36/b93fdf0bc6f84f0cd487aadfb0354deb40013669ea35ac3d26855de1e959/ruff-0.17.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:39405f341deec934b4289634324ad695f72df2970f9121582872eaf5b722f0f5", size = 10608748, upload-time = "2026-10-27T00:33:50.284Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b7/7d3f5f14145daead1efb0b9a8289ed1daa100f419d60774375951723ce00/ruff-0.17.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68074094f55ca3d29ab19491f640282f7a84061c4c7977aa5094b968ca457e9a", size = 10075057, upload-time = "2026-10-27T00:33:52.074Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ed/93ff7a5909ee56e2bd4b982deae9e0efb2724417874a90c9e41ad66c6dd7/ruff-0.17.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:27bb571ac78fef178fe5118d2827df95c2aae74a48fff2b15f6acd03af5ff5bb", size = 10022431, upload-time = "2026-10-27T00:33:54.061Z" }, + { url = "https://files.pythonhosted.org/packages/9b/07/a83b9eeec8c1c3c0e4eda15f06c3a91001bfd2687ea2f07b750719bf9712/ruff-0.17.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:029c37cbd3de48ca37aa12117bead2d065f15da17d66bf84e0d4274013705db2", size = 10394903, upload-time = "2026-10-27T00:33:56.158Z" }, + { url = "https://files.pythonhosted.org/packages/af/b2/05c39857c2526fcbebe46ad93a8dc97424656dfef14d3ef933abe1ffd331/ruff-0.17.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:692fdb46d0fd9c71e380947dc5fc72f2c3f881073bc1f739e4579376231affbe", size = 10799780, upload-time = "2026-10-27T00:33:58.204Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d9/47171a16739eb7a353936b31c20cf54340531e68c9af7d72fd7a784e235d/ruff-0.17.3-py3-none-win32.whl", hash = "sha256:46539cb031b01fd29ae0a02142483c46640b233ee12bb1c1b690bffa1555d5ca", size = 9908481, upload-time = "2026-10-27T00:34:00.087Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a0/f08c1631bfd81faa6a90eaf70c37c786c11bed2046302b56bb506c25e1a0/ruff-0.17.3-py3-none-win_amd64.whl", hash = "sha256:56b8ffb3f3b3cbccb8b76b71b38261b7ed982ef5d20f5b447b1b61a7f4949b24", size = 10341333, upload-time = "2026-10-27T00:34:02.099Z" }, + { url = "https://files.pythonhosted.org/packages/99/d5/4ad4ed31413c301430918e70d3d38ae6f097af0766cb9ab8c9d502b2a4d6/ruff-0.17.3-py3-none-win_arm64.whl", hash = "sha256:81fce74bcd6be0e9da7c67c7553fd0f1f12964a2052cd728ef917b937a5ca1d9", size = 9854332, upload-time = "2026-10-27T00:34:03.847Z" }, +] + +[[package]] +name = "secretstorage" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "jeepney" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" }, +] + +[[package]] +name = "setuptools" +version = "84.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/b3/c19426f783614d625699a4b247faf628ea9ab1db228674491767b417f9e1/setuptools-84.2.1.tar.gz", hash = "sha256:3ff8b3b5492a0aa66960f4419365a86b84e013070d4313e4d4a6894f5d64d6bc", size = 1230289, upload-time = "2026-10-20T19:01:37.742Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/55/6dc6d6bb953bdfc52519a0059592c52b6e3b8ad51cf8256dffceb55b0610/setuptools-84.2.1-py3-none-any.whl", hash = "sha256:ca140b45d5325a9478f880e351484f62fef15f336462e449ca0c03c873d589c2", size = 876263, upload-time = "2026-10-20T19:01:35.678Z" }, +] + +[[package]] +name = "toml" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" }, +] + +[[package]] +name = "tomli-w" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" }, +] + +[[package]] +name = "toon-format" +version = "1.2.0" +source = { git = "https://github.com/toon-format/toon-python.git#536a508d486847cb01ec1869cf21d1f7556b0db0" } + +[[package]] +name = "twine" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "id" }, + { name = "keyring", marker = "platform_machine != 'ppc64le' and platform_machine != 's390x'" }, + { name = "packaging" }, + { name = "readme-renderer" }, + { name = "requests" }, + { name = "requests-toolbelt" }, + { name = "rfc3986" }, + { name = "rich" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/92/3c/58f808a359700f39a967dffede33efeac809262c03303fa3eec6afff8f49/twine-7.0.0.tar.gz", hash = "sha256:85cdb29c518efef867360ae4acd4b0dfd61c8654a22fca08e6f8539f05022177", size = 215032, upload-time = "2026-07-27T15:59:00.825Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/08/ddcdc06225eaad6de0e48e1002b06d919dbde20582d0662c7af51308e5d6/twine-7.0.0-py3-none-any.whl", hash = "sha256:b854164df26db268af05f49aa5c0344b10e27a494343ff05b1e0bad3b135f5a7", size = 43204, upload-time = "2026-07-27T15:58:59.26Z" }, +] + +[[package]] +name = "types-pyyaml" +version = "6.0.12.20261103" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d9/82/2ed4d215a2840b467a9a864f03b0d21904250e28f5e1f006ad36fba0311a/types_pyyaml-6.0.12.20261103.tar.gz", hash = "sha256:7a1b5f837881dd35d5448b5f18275164f89f206185e31e8eae6e0b42607bc001", size = 18911, upload-time = "2026-11-03T08:45:23.714Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/10/4353eb86278f6a59aeb9fe2be4d979c20b110b4009fa455a3ea6467cf5cb/types_pyyaml-6.0.12.20261103-py3-none-any.whl", hash = "sha256:444654c61f635dab82c092a511aa96a0ce31164810784b9a37314e3e56532ac8", size = 21299, upload-time = "2026-11-03T08:45:22.749Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "urllib3" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" }, +] + +[[package]] +name = "virtualenv" +version = "21.15.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "packaging" }, + { name = "platformdirs" }, + { name = "python-discovery" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c3/29/766593bdf0631aed6833e0f36f9495e0aad6325ce52754977beb895a4d83/virtualenv-21.15.4.tar.gz", hash = "sha256:105b395ce731f1cd086378037c9e20fadbb2aef98836d19b6d5767f622d21de1", size = 5640989, upload-time = "2026-11-04T01:29:34.982Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/92/6789235837302508926b5a58d3f3aa098d3c294e381baed5d4cb202a6e6e/virtualenv-21.15.4-py3-none-any.whl", hash = "sha256:a66dfba5f608b3a1778d86ddf6a63a611f394934bb2cffd13ae6962b98b9798f", size = 5680750, upload-time = "2026-11-04T01:29:32.4Z" }, +] + +[[package]] +name = "wheel" +version = "0.48.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/20/50ed6bdf27dec98b568a8ae25dc599f35baa3d9709f9e83fd1edb56b9a90/wheel-0.48.0.tar.gz", hash = "sha256:94800765601e9171bf5d58d066e640662842bcedcbab982b2c90787a2c987322", size = 66471, upload-time = "2026-08-11T22:02:27.327Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/29/69cfbb602cd91690c55d38ba9fe53e6a7e76a6fa647bf38f19c138d25449/wheel-0.48.0-py3-none-any.whl", hash = "sha256:3217dcc807155e45db462d7ef2431f5ddda0d7273b700d05a67b271ceb1287ab", size = 33320, upload-time = "2026-08-11T22:02:26.1Z" }, +] + +[[package]] +name = "zipp" +version = "4.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/05/ba1458dee0ac485b2a01071c1b88f5199fe878a485df482e10e1ef2205cc/zipp-4.1.2.tar.gz", hash = "sha256:cf474b90b07ea932637e17c6b9479de2b2882900b0d311bdaf4f5c000a15a97f", size = 27864, upload-time = "2026-10-21T18:57:04.743Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/44/7bd2007260da11cccca29ba2d4c345f1287aa663db38ee7cefeabf6386a5/zipp-4.1.2-py3-none-any.whl", hash = "sha256:b30cb6cd253122169c47de245ca24a86bac2a5d3802ba15bf7ba6414eb9e144d", size = 10581, upload-time = "2026-10-21T18:57:03.79Z" }, +] From b9c93d972d6eed1fbae23a5731fba30c1945a84a Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:02:30 -0500 Subject: [PATCH 42/61] Use uv in GitHub workflows, update README and CONTRIBUTING for uv/ruff and pyproject builds - tests.yml/pythonpublish.yml use astral-sh/setup-uv, uv sync/build and uvx twine/cibuildwheel (same matrix, targets and secrets) - add a ruff lint/format-check job - document building the Cython version with --no-build-isolation now that metadata is in pyproject.toml Co-Authored-By: Claude Sonnet 5.5 --- .github/workflows/pythonpublish.yml | 47 ++++++---------- .github/workflows/tests.yml | 87 +++++++++++++---------------- CONTRIBUTING.rst | 38 ++++++++++++- README.rst | 17 +++--- 4 files changed, 104 insertions(+), 85 deletions(-) diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index b11d5f0..600206b 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -20,20 +20,18 @@ jobs: with: python-version: '3.15' - - name: Install Dependencies - run: | - python -m pip install --upgrade pip - pip install setuptools wheel twine --upgrade - + - name: Install uv + uses: astral-sh/setup-uv@v10 + # Isolated build: Cython is not part of the build requirements, so this is the pure Python sdist and wheel - name: Build and Publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: | - python setup.py sdist bdist_wheel - twine upload dist/* + uv build + uvx twine upload dist/* deploy-cython: strategy: @@ -48,44 +46,35 @@ jobs: uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} - - name: Install dependencies + - name: Install uv + uses: astral-sh/setup-uv@v10 + - name: Install build dependencies run: | - python -m pip install --upgrade pip - pip install setuptools wheel twine Cython>=3.3.0 --upgrade + uv venv + uv pip install "setuptools>=77" wheel "Cython>=3.3.0" - name: Build and publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} + # No build isolation so the Cython installed above is used to build the compiled wheel run: | - python setup.py bdist_wheel - twine upload dist/* + uv build --wheel --no-build-isolation + uvx twine upload dist/* deploy-cython-manylinux: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7 - - name: Set up Python 3.14 - uses: actions/setup-python@v7 - with: - python-version: "3.14" + - name: Install uv + uses: astral-sh/setup-uv@v10 + # Build targets and test commands are configured in [tool.cibuildwheel] in pyproject.toml - name: Build wheels - run: | - python -m pip install --upgrade pip - pip install cibuildwheel setuptools wheel - python -m cibuildwheel --output-dir dist - env: - CIBW_BUILD: cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64 cp315-manylinux_x86_64 - CIBW_BEFORE_BUILD: pip install Cython>=3.3.0 setuptools wheel - CIBW_BUILD_FRONTEND: "build; args: --no-isolation" - CIBW_BEFORE_TEST: pip install -r requirements.txt -r requirements-test.txt setuptools wheel twine Cython>=3.3.0 - CIBW_BUILD_VERBOSITY: 1 - CIBW_TEST_COMMAND: pytest {package}/test -vv + run: uvx cibuildwheel --output-dir dist - name: Publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: | - pip install twine - twine upload dist/*-manylinux*.whl + uvx twine upload dist/*-manylinux*.whl diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index e95778f..f06f154 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -10,6 +10,19 @@ on: branches: [ master, development, develop, test, tests ] jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - name: Install uv + uses: astral-sh/setup-uv@v10 + with: + enable-cache: true + - name: Ruff lint + run: uvx ruff check . + - name: Ruff format + run: uvx ruff format --check . + package-checks: strategy: matrix: @@ -22,36 +35,33 @@ jobs: uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} -# - uses: actions/cache@v3 -# with: -# path: ~/.cache/pip -# key: package-check-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements-test.txt') }} + - name: Install uv + uses: astral-sh/setup-uv@v10 + with: + enable-cache: true - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install -r requirements.txt - pip install -r requirements-test.txt - pip install coveralls mypy setuptools wheel twine Cython>=3.3.0 + # Cython is part of the dev group, so the build below produces a compiled wheel + run: uv sync --group dev --no-install-project - name: Run mypy if: "!startsWith(matrix.python-version, 'pypy')" - run: mypy box - - name: Build Wheel and check distribution log description + run: uv run --no-sync mypy box + - name: Build sdist and wheel and check distribution log description run: | - python setup.py sdist bdist_wheel - twine check dist/* + uv build --no-build-isolation + uv run --no-sync twine check dist/* - name: Test packaged wheel on *nix if: matrix.os != 'windows-latest' run: | - pip install dist/*.whl + uv pip install --reinstall dist/*.whl rm -rf box - python -m pytest -vv + uv run --no-sync pytest -vv - name: Test packaged wheel on Windows if: matrix.os == 'windows-latest' run: | $wheel = (Get-ChildItem dist\*.whl | Sort lastWriteTime | Select-Object -last 1).Name - pip install dist\${wheel} + uv pip install --reinstall dist\${wheel} Remove-item box -recurse -force - python -m pytest -vv + uv run --no-sync pytest -vv - name: Upload wheel artifact uses: actions/upload-artifact@v7 with: @@ -62,28 +72,13 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7 - - name: Set up Python 3.14 - uses: actions/setup-python@v7 + - name: Install uv + uses: astral-sh/setup-uv@v10 with: - python-version: "3.14" - -# - uses: actions/cache@v3 -# with: -# path: ~/.cache/pip -# key: package-manylinux-check-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements-test.txt') }} - + enable-cache: true + # Build targets and test commands are configured in [tool.cibuildwheel] in pyproject.toml - name: Build wheels - run: | - python -m pip install --upgrade pip - pip install cibuildwheel - python -m cibuildwheel --output-dir dist - env: - CIBW_BUILD: cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64 cp315-manylinux_x86_64 - CIBW_BEFORE_BUILD: pip install Cython>=3.3.0 setuptools wheel - CIBW_BUILD_FRONTEND: "build; args: --no-isolation" - CIBW_BEFORE_TEST: pip install -r requirements.txt -r requirements-test.txt setuptools wheel twine Cython>=3.3.0 - CIBW_BUILD_VERBOSITY: 1 - CIBW_TEST_COMMAND: pytest {package}/test -vv + run: uvx cibuildwheel --output-dir dist - name: Upload wheel artifact uses: actions/upload-artifact@v7 @@ -103,19 +98,17 @@ jobs: uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} -# - uses: actions/cache@v3 -# with: -# path: ~/.cache/pip -# key: test-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements-test.txt') }} + - name: Install uv + uses: astral-sh/setup-uv@v10 + with: + enable-cache: true - name: Install dependencies run: | - python -m pip install --upgrade pip - pip install -r requirements.txt - pip install -r requirements-test.txt - pip install setuptools wheel Cython>=3.3.0 - python setup.py build_ext --inplace + uv sync --group dev --no-install-project + # Editable install without build isolation compiles box in place using the Cython from the dev group + uv pip install -e . --no-build-isolation - name: Test with pytest env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | - pytest --cov=box -vv test/ + uv run --no-sync pytest --cov=box -vv test/ diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 8792eec..8a689d3 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -18,10 +18,46 @@ Reporting Bugs - Also include Python version and Operating System. +Development Setup +----------------- + +Box uses `uv `_ to manage the development environment, and +`ruff `_ for linting and formatting (line length 120, Black compatible style). +All project metadata and tool configuration lives in ``pyproject.toml``. + +.. code:: bash + + # create the environment (all test dependencies plus the dev tools) + uv sync --group dev + + # run the tests + uv run pytest + + # lint, format and type check + uv run ruff check --fix . + uv run ruff format . + uv run mypy box + + # optional: run the checks automatically before each commit + uv run pre-commit install + +To test the Cython compiled version, install the package in the environment without build isolation +(so the Cython from the ``dev`` group is used), then run the tests again: + +.. code:: bash + + uv pip install -e . --no-build-isolation + uv run --no-sync pytest + +Build the (pure Python) source distribution and wheel with ``uv build``, or the compiled wheel for your +platform with ``uv build --no-build-isolation``. + +When you change dependencies in ``pyproject.toml`` run ``uv lock`` and commit the updated ``uv.lock``. + Pull Requests ------------- -- Follow PEP8 +- Follow PEP8 (``ruff check`` and ``ruff format --check`` should pass) - Select to merge into `develop` branch, NOT `master` diff --git a/README.rst b/README.rst index f67d6ad..c5e71ac 100644 --- a/README.rst +++ b/README.rst @@ -33,7 +33,7 @@ requirements.txt .. code:: text - python-box[all]~=7.0 + python-box[all]~=8.0 As Box adheres to semantic versioning (aka API changes will only occur on between major version), it is best to use `Compatible release `_ matching using the `~=` clause. @@ -44,7 +44,7 @@ Install from command line .. code:: bash python -m pip install --upgrade pip - pip install "python-box[all]~=7.0" --upgrade + pip install "python-box[all]~=8.0" --upgrade Install with selected dependencies ---------------------------------- @@ -54,14 +54,14 @@ for example, `[all]` is shorthand for: .. code:: bash - pip install "python-box[ruamel.yaml,toml,msgpack]~=7.0" --upgrade + pip install "python-box[ruamel.yaml,toml,msgpack]~=8.0" --upgrade But you can also sub out `ruamel.yaml` for `PyYAML`. To use ``tomli-w`` for TOML output, select the ``tomli`` extra instead of ``toml``. Check out `more details `_ on installation details. -Box 7 is tested on python 3.7+, if you are upgrading from previous versions, please look through +Box 8 is tested on python 3.11+, if you are upgrading from previous versions, please look through `any breaking changes and new features `_. Optimized Version @@ -72,17 +72,18 @@ Loading large data sets can be up to 10x faster! If you are **not** on a x86_64 supported system you will need to do some extra work to install the optimized version. There will be an warning of "WARNING: Cython not installed, could not optimize box" during install. -You will need python development files, system compiler, and the python packages `Cython` and `wheel`. +You will need python development files, system compiler, and the python packages `Cython`, `setuptools` and `wheel`. **Linux Example:** First make sure you have python development files installed (`python3-dev` or `python3-devel` in most repos). -You will then need `Cython` and `wheel` installed and then install (or re-install with `--force`) `python-box`. +You will then need `Cython`, `setuptools` and `wheel` installed and then install (or re-install with `--force`) `python-box`. +As Cython is not a build requirement, the build has to run without isolation so it can see your installed copy. .. code:: bash - pip install Cython wheel - pip install "python-box[all]~=7.0" --upgrade --force + pip install Cython "setuptools>=77" wheel + pip install "python-box[all]~=8.0" --upgrade --force --no-binary python-box --no-build-isolation If you have any issues please open a github issue with the error you are experiencing! From 77b7cb5204c631f3fac53cb035dc36d6e831b094 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:04:35 -0500 Subject: [PATCH 43/61] Apply ruff format/lint Mechanical changes from ruff format and ruff check --fix (import sorting, unused imports, quote style), plus noqa for the few intentional findings (== True assertions, one long test string). box/__init__.py is excluded from F401/I001 via per-file-ignores because its import order matters. config_box.pyi uses builtins.bool instead of a type-ignore that the formatter would have moved. Co-Authored-By: Claude Sonnet 5.5 --- box/box.py | 16 ++++++++-------- box/box.pyi | 3 ++- box/box_list.py | 2 +- box/box_list.pyi | 15 ++++++++++++--- box/config_box.pyi | 13 +++++++++++-- box/converters.py | 6 +++--- box/from_file.py | 4 +--- box/from_file.pyi | 5 +++-- pyproject.toml | 4 ++++ test/test_box.py | 26 +++++++++++++------------- test/test_box_list.py | 8 +++----- test/test_config_box.py | 3 +-- test/test_converters.py | 4 ++-- test/test_from_file.py | 2 +- test/test_sbox.py | 4 +--- 15 files changed, 66 insertions(+), 49 deletions(-) diff --git a/box/box.py b/box/box.py index 4bf8fa9..c2e6655 100644 --- a/box/box.py +++ b/box/box.py @@ -17,7 +17,6 @@ from os import PathLike from typing import Any, Literal - import box from box.converters import ( BOX_PARAMETERS, @@ -32,9 +31,9 @@ _to_toon, _to_yaml, msgpack_available, - toon_available, toml_read_library, toml_write_library, + toon_available, yaml_available, ) from box.exceptions import BoxError, BoxKeyError, BoxTypeError, BoxValueError, BoxWarning @@ -741,8 +740,9 @@ def _flush_pending_parent(self): not stored in its parent. The first time something is actually written to that child, attach it (and any ephemeral ancestors) to the parent so `b.a.b = 1` creates `a`. - Nothing is attached if the key has been given a real value since the child was handed out: the stale child is left detached rather than overwriting - data, so writes to it are lost just like any other ephemeral lookup. + Nothing is attached if the key has been given a real value since the child was handed out: + the stale child is left detached rather than overwriting data, so writes to it are lost + just like any other ephemeral lookup. """ pending = self._box_config.pop("__pending_parent", None) if pending is None: @@ -1085,7 +1085,7 @@ def _safe_attr(self, attr): return attr if sum(1 for character in attr if character.isidentifier() and not iskeyword(character)) == 0: - attr = f'{self.__box_config()["box_safe_prefix"]}{attr}' + attr = f"{self.__box_config()['box_safe_prefix']}{attr}" if attr.isidentifier() and not iskeyword(attr): return attr @@ -1108,10 +1108,10 @@ def _safe_attr(self, attr): except (ValueError, IndexError): pass else: - out = f'{self.__box_config()["box_safe_prefix"]}{out}' + out = f"{self.__box_config()['box_safe_prefix']}{out}" if iskeyword(out): - out = f'{self.__box_config()["box_safe_prefix"]}{out}' + out = f"{self.__box_config()['box_safe_prefix']}{out}" return out @@ -1124,7 +1124,7 @@ def _conversion_checks(self, item): safe_item = self._safe_attr(item) if safe_item in self._box_config["__safe_keys"] and self._box_config["__safe_keys"][safe_item] != item: - dups = [f"{item}({safe_item})", f'{self._box_config["__safe_keys"][safe_item]}({safe_item})'] + dups = [f"{item}({safe_item})", f"{self._box_config['__safe_keys'][safe_item]}({safe_item})"] if self._box_config["box_duplicates"].startswith("warn"): warnings.warn(f"Duplicate conversion attributes exist: {dups}", BoxWarning) else: diff --git a/box/box.pyi b/box/box.pyi index 05f0906..2c65225 100644 --- a/box/box.pyi +++ b/box/box.pyi @@ -1,8 +1,9 @@ -from _typeshed import Incomplete from collections.abc import Generator, Mapping from os import PathLike from typing import Any, Literal +from _typeshed import Incomplete + class Box(dict): def __new__( cls, diff --git a/box/box_list.py b/box/box_list.py index 5c6b620..0526fd2 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -26,8 +26,8 @@ _to_toon, _to_yaml, msgpack_available, - toon_available, toml_read_library, + toon_available, yaml_available, ) from box.exceptions import BoxError, BoxTypeError diff --git a/box/box_list.pyi b/box/box_list.pyi index a9e769e..c7f2470 100644 --- a/box/box_list.pyi +++ b/box/box_list.pyi @@ -1,14 +1,23 @@ +from collections.abc import Iterable +from os import PathLike as PathLike +from typing import Any + import box from box.converters import ( BOX_PARAMETERS as BOX_PARAMETERS, +) +from box.converters import ( msgpack_available as msgpack_available, +) +from box.converters import ( toml_read_library as toml_read_library, +) +from box.converters import ( toml_write_library as toml_write_library, +) +from box.converters import ( yaml_available as yaml_available, ) -from collections.abc import Iterable -from os import PathLike as PathLike -from typing import Any class BoxList(list): def __new__(cls, *args: Any, **kwargs: Any): ... diff --git a/box/config_box.pyi b/box/config_box.pyi index 6d72f27..26ccdcc 100644 --- a/box/config_box.pyi +++ b/box/config_box.pyi @@ -1,13 +1,22 @@ -from box.box import Box as Box +import builtins from typing import Any +from box.box import Box as Box + class ConfigBox(Box): def __getattr__(self, item: Any): ... def __dir__(self) -> list[str]: ... def bool(self, item: Any, default: Any | None = ...): ... def int(self, item: Any, default: Any | None = ...): ... def float(self, item: Any, default: Any | None = ...): ... - def list(self, item: Any, default: Any | None = ..., spliter: str = ..., strip: bool = ..., mod: Any | None = ...): ... # type: ignore + def list( + self, + item: Any, + default: Any | None = ..., + spliter: str = ..., + strip: builtins.bool = ..., + mod: Any | None = ..., + ): ... def getboolean(self, item: Any, default: Any | None = ...): ... def getint(self, item: Any, default: Any | None = ...): ... def getfloat(self, item: Any, default: Any | None = ...): ... diff --git a/box/converters.py b/box/converters.py index 39def1b..53fddbb 100644 --- a/box/converters.py +++ b/box/converters.py @@ -3,7 +3,6 @@ from __future__ import annotations # Abstract converter functions for use in any Box class - import csv import json from collections.abc import Callable @@ -19,7 +18,7 @@ msgpack_available = True try: - from ruamel.yaml import version_info, YAML + from ruamel.yaml import YAML, version_info except ImportError: ruamel_available = False else: @@ -111,7 +110,8 @@ class BoxTomlDecodeError(BoxError, tomli.TOMLDecodeError): # type: ignore toon_available = True try: - from toon_format import encode as toon_encode, decode as toon_decode + from toon_format import decode as toon_decode + from toon_format import encode as toon_encode except ImportError: toon_available = False diff --git a/box/from_file.py b/box/from_file.py index 3fb7a6e..e3a84af 100644 --- a/box/from_file.py +++ b/box/from_file.py @@ -2,15 +2,13 @@ # -*- coding: utf-8 -*- from __future__ import annotations -import sys -from collections.abc import Callable from json import JSONDecodeError from os import PathLike from pathlib import Path from box.box import Box from box.box_list import BoxList -from box.converters import msgpack_available, toon_available, toml_read_library, yaml_available, toml_decode_error +from box.converters import msgpack_available, toml_decode_error, toml_read_library, toon_available, yaml_available from box.exceptions import BoxError try: diff --git a/box/from_file.pyi b/box/from_file.pyi index bae0c57..8d1d7da 100644 --- a/box/from_file.pyi +++ b/box/from_file.pyi @@ -1,8 +1,9 @@ -from box.box import Box as Box -from box.box_list import BoxList as BoxList from os import PathLike from typing import Any +from box.box import Box as Box +from box.box_list import BoxList as BoxList + def box_from_file( file: str | PathLike, file_type: str = ..., diff --git a/pyproject.toml b/pyproject.toml index 71c3484..6c46606 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -98,6 +98,10 @@ line-ending = "auto" # Deliberately conservative: pycodestyle, pyflakes and import sorting only select = ["E", "F", "W", "I"] +[tool.ruff.lint.per-file-ignores] +# The package imports are order sensitive (circular imports) and re-exported on purpose +"box/__init__.py" = ["F401", "I001"] + [tool.ruff.lint.isort] # "test" is also a stdlib module name, make sure our test package is sorted with the first party code known-first-party = ["box", "test"] diff --git a/test/test_box.py b/test/test_box.py index a87ff46..b1fc546 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -8,9 +8,17 @@ import platform import shutil import warnings +from io import StringIO from multiprocessing import Queue from pathlib import Path -from io import StringIO + +import pytest +from ruamel.yaml import YAML + +from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox, DDBox, SBox +from box.box import _camel_killer, _get_dot_paths, _recursive_tuples # type: ignore +from box.converters import BOX_PARAMETERS +from box.exceptions import BoxWarning from test.common import ( data_json_file, data_yaml_file, @@ -25,14 +33,6 @@ tmp_yaml_file, ) -import pytest -from ruamel.yaml import YAML - -from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox, SBox, DDBox -from box.exceptions import BoxWarning -from box.box import _get_dot_paths, _camel_killer, _recursive_tuples # type: ignore -from box.converters import BOX_PARAMETERS - class _SubclassBox(Box): """Module-level Box subclass so its instances are picklable in tests.""" @@ -1205,7 +1205,7 @@ def test_dots_exclusion(self): box_dots=True, box_dots_exclude=r"[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+", ) - assert bx["0.0.0.1"] == True + assert bx["0.0.0.1"] == True # noqa: E712 with pytest.raises(BoxKeyError): del bx["0"] @@ -1618,7 +1618,7 @@ def test_setdefault_simple(self): assert box["b"] == 2 assert box["c"] == "test" assert isinstance(box["d"], Box) - assert box["d"]["e"] == True + assert box["d"]["e"] == True # noqa: E712 assert isinstance(box["f"], BoxList) assert box["f"][1] == 2 @@ -1633,7 +1633,7 @@ def test_setdefault_dots(self): assert box.b == 2 assert box.c.e == "test" assert isinstance(box["d"], Box) - assert box.d.e == True + assert box.d.e == True # noqa: E712 assert isinstance(box["f"], BoxList) assert box.f[1] == 2 @@ -1737,7 +1737,7 @@ def field(self): assert box.field == 5 assert box._field == 5 del box.field - assert not "_field" in box + assert "_field" not in box def test_box_namespace(self): bx = Box(default_box=True) diff --git a/test/test_box_list.py b/test/test_box_list.py index c43e5ff..c92cfd2 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -7,17 +7,15 @@ import os import pickle import shutil -import sys -import platform -from pathlib import Path from io import StringIO -from test.common import test_root, tmp_dir +from pathlib import Path import pytest from ruamel.yaml import YAML from box import Box, BoxError, BoxList from box.converters import toml_read_library, toml_write_library +from test.common import test_root, tmp_dir class TestBoxList: @@ -386,7 +384,7 @@ def test_from_csv(self): bl = BoxList.from_csv(filename=Path(test_root, "data", "csv_file.csv")) assert bl[1].Name == "Sam" b2 = BoxList.from_csv( - "Number,Name,Country\r\n1,Chris,US\r\n2,Sam" ",US\r\n3,Jess,US\r\n4,Frank,UK\r\n5,Demo,CA\r\n" + "Number,Name,Country\r\n1,Chris,US\r\n2,Sam,US\r\n3,Jess,US\r\n4,Frank,UK\r\n5,Demo,CA\r\n" ) assert b2[2].Name == "Jess" diff --git a/test/test_config_box.py b/test/test_config_box.py index 345ed55..59089df 100644 --- a/test/test_config_box.py +++ b/test/test_config_box.py @@ -1,9 +1,8 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -from test.common import test_dict - from box import Box, ConfigBox +from test.common import test_dict class TestConfigBox: diff --git a/test/test_converters.py b/test/test_converters.py index 5d66315..011436c 100644 --- a/test/test_converters.py +++ b/test/test_converters.py @@ -4,7 +4,6 @@ import os import shutil from pathlib import Path -from test.common import movie_data, tmp_dir import msgpack import pytest @@ -12,6 +11,7 @@ from box import Box, BoxError, BoxList from box.converters import _from_toml, _to_json, _to_msgpack, _to_toml, _to_yaml +from test.common import movie_data, tmp_dir toml_string = """[movies.Spaceballs] imdb_stars = 7.1 @@ -141,5 +141,5 @@ def test_to_msgpack(self): def test_to_yaml_ruamel(self): movie_string = _to_yaml(movie_data, ruamel_attrs={"width": 12}) - multiline_except = """ - name: \n Roger\n Rees\n imdb: \n nm0715953\n role: \n Sheriff\n of \n Rottingham\n - name: \n Amy \n Yasbeck""" + multiline_except = """ - name: \n Roger\n Rees\n imdb: \n nm0715953\n role: \n Sheriff\n of \n Rottingham\n - name: \n Amy \n Yasbeck""" # noqa: E501 assert multiline_except in movie_string diff --git a/test/test_from_file.py b/test/test_from_file.py index 7361e84..6569028 100644 --- a/test/test_from_file.py +++ b/test/test_from_file.py @@ -1,11 +1,11 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- from pathlib import Path -from test.common import test_root import pytest from box import Box, BoxError, BoxList, box_from_file, box_from_string +from test.common import test_root class TestFromFile: diff --git a/test/test_sbox.py b/test/test_sbox.py index ea0d06a..2725ba5 100644 --- a/test/test_sbox.py +++ b/test/test_sbox.py @@ -1,13 +1,11 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- import json -from test.common import test_dict - -import pytest from ruamel.yaml import YAML from box import Box, SBox +from test.common import test_dict class TestSBox: From cd26bd1e55d116a0af7c438bf2309b77ed794242 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:05:05 -0500 Subject: [PATCH 44/61] Update type stubs: Self for copy/__copy__/__deepcopy__, _box_internal_attrs Co-Authored-By: Claude Sonnet 5.5 --- box/box.pyi | 9 +++++---- box/config_box.pyi | 2 -- box/shorthand_box.pyi | 2 -- 3 files changed, 5 insertions(+), 8 deletions(-) diff --git a/box/box.pyi b/box/box.pyi index 2c65225..a1dbfdd 100644 --- a/box/box.pyi +++ b/box/box.pyi @@ -1,10 +1,11 @@ from collections.abc import Generator, Mapping from os import PathLike -from typing import Any, Literal +from typing import Any, Literal, Self from _typeshed import Incomplete class Box(dict): + _box_internal_attrs: tuple[str, ...] def __new__( cls, *args: Any, @@ -60,9 +61,9 @@ class Box(dict): def keys(self, dotted: bool = ...): ... def items(self, dotted: bool = ...): ... def get(self, key, default=...): ... - def copy(self) -> Box: ... - def __copy__(self) -> Box: ... - def __deepcopy__(self, memodict: Incomplete | None = ...) -> Box: ... + def copy(self) -> Self: ... + def __copy__(self) -> Self: ... + def __deepcopy__(self, memodict: Incomplete | None = ...) -> Self: ... def __getitem__(self, item, _ignore_default: bool = ...): ... def __getattr__(self, item): ... def __setitem__(self, key, value): ... diff --git a/box/config_box.pyi b/box/config_box.pyi index 26ccdcc..b8bff36 100644 --- a/box/config_box.pyi +++ b/box/config_box.pyi @@ -20,5 +20,3 @@ class ConfigBox(Box): def getboolean(self, item: Any, default: Any | None = ...): ... def getint(self, item: Any, default: Any | None = ...): ... def getfloat(self, item: Any, default: Any | None = ...): ... - def copy(self) -> ConfigBox: ... - def __copy__(self) -> ConfigBox: ... diff --git a/box/shorthand_box.pyi b/box/shorthand_box.pyi index be577f2..1f39087 100644 --- a/box/shorthand_box.pyi +++ b/box/shorthand_box.pyi @@ -9,7 +9,5 @@ class SBox(Box): def yaml(self) -> str: ... @property def toml(self) -> str: ... - def copy(self) -> SBox: ... - def __copy__(self) -> SBox: ... class DDBox(Box): ... From 87460765b88cde554e1cded4d15cf0bc9c4385fe Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:05:05 -0500 Subject: [PATCH 45/61] Finalize 8.0.0 changelog with a breaking changes section Co-Authored-By: Claude Sonnet 5.5 --- CHANGES.rst | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/CHANGES.rst b/CHANGES.rst index 134fcef..3119313 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -4,7 +4,16 @@ Changelog Version 8.0.0 ------------- -* BREAKING CHANGE: Box.popitem() now removes the most recently inserted item (LIFO) like dict.popitem(), instead of the first inserted item (thanks to machines-6657) +Breaking changes + +* Box.popitem() now removes the most recently inserted item (LIFO) like dict.popitem(), instead of the first inserted item (thanks to machines-6657) +* Removing support for Python 3.10 as it is EOL, Python 3.11+ is now required +* merge_update now raises BoxValueError for an unrecognized box_merge_lists value instead of silently replacing the list +* Box.copy() / copy.copy() / copy.deepcopy() now return the same class as the original (subclasses of Box, ConfigBox, SBox and DDBox were previously turned into a plain Box / ConfigBox / SBox) +* Build and development tooling changed (see below): installing from an sdist now needs setuptools>=77, and building the Cython version from source requires --no-build-isolation + +Changes + * Fixing #274 default_box_create_on_get=False not creating missing parent keys on assignment, e.g. box.a.b = 1 (thanks to gyanu2507 for the fix and wrdls for reporting) * Adding #263 "merge" option for box_merge_lists to merge lists of dictionaries element by element (thanks to ChrisJr404) * Adding #269 internal-only attributes for Box subclasses via _box_internal_attrs (thanks to bwanshoom and gtkacz for the suggestion) @@ -19,7 +28,7 @@ Version 8.0.0 * Fixing #305 dotted keys lost with box_dots when a non-dotted key with the same prefix follows (thanks to J vanBemmel) * Fixing #308 subclass of Box not preserved for nested boxes after unpickling (thanks to koriyoshi2041) * Fixing #344 frozen BoxList instances could not be pickled (thanks to Abhinav Maurya) -* Fixing frozen BoxList could be mutated via clear, += and *= (thanks to Vitaliy Voloshin) +* Fixing frozen BoxList could be mutated via clear, ``+=`` and ``*=`` (thanks to Vitaliy Voloshin) * Fixing BoxList.__deepcopy__ not preserving box options (thanks to chuenchen309) * Fixing second dotted write into an existing BoxList element discarding data (thanks to binggao1230) * Fixing dicts and lists assigned to BoxList items and slices not being converted (thanks to x0Lazarus) @@ -31,10 +40,10 @@ Version 8.0.0 * Fixing Box.update not accepting a positional source and keyword overrides together like dict.update (thanks to AryanRG) * Fixing duplicate conversion check raising when re-assigning the same key (thanks to Muneeb Sheikh) * Fixing deleted keys not releasing their converted attribute alias (thanks to Gary) -* Changing merge_update to raise BoxValueError for an unrecognized box_merge_lists value instead of silently replacing the list * Fixing Box.copy() (and copy.copy / copy.deepcopy) returning a plain Box, ConfigBox or SBox instead of the same subclass +* Moving package metadata from setup.py to pyproject.toml (PEP 621), setup.py now only handles the optional Cython build +* Moving development and CI to uv (dependency groups and uv.lock replace the requirements files) and ruff (replaces black) * Fixing optional dependency installation examples in README (thanks to Likio3000) -* Removing support for Python 3.10 as it is EOL Version 7.4.1 ------------- From ef0d795e2857b4236a5dd828287ba10ba47591fb Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:05:23 -0500 Subject: [PATCH 46/61] Add bwanshoom to AUTHORS for the #269 suggestion Co-Authored-By: Claude Sonnet 5.5 --- AUTHORS.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/AUTHORS.rst b/AUTHORS.rst index 581ab5c..e42c1d0 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -118,3 +118,4 @@ Suggestions and bug reporting: - d00m514y3r - Sébastien Weber (seb5g) - Ward Loos (wrdls) +- bwanshoom From c54936a8ff404d4d5bdc06ea370dca101380ae8c Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:10:56 -0500 Subject: [PATCH 47/61] Review fixes for CI supply chain and build config - Use toon-format 1.2.0 from PyPI instead of an unpinned git URL (now hash-locked in uv.lock, and pinned for cibuildwheel/pip which read pyproject) - Split manylinux publish into a build job (runs tests, no secrets) and an upload-only job, so third party test deps never run alongside PyPI creds - Quote Cython>=3.3.0 in cibuildwheel before-build (was a shell redirect) - Pin uvx tools (ruff 0.17.3 to match lock/pre-commit, cibuildwheel 4.3.5, twine 6.2.0) so CI does not drift - Point uv at the setup-python interpreter (UV_PYTHON) in matrix jobs so each cell, including pypy, tests the interpreter it claims to Co-Authored-By: Claude Opus 5.5 --- .github/workflows/pythonpublish.yml | 35 ++++++++++++++++++++++++----- .github/workflows/tests.yml | 14 +++++++++--- pyproject.toml | 4 ++-- uv.lock | 10 ++++++--- 4 files changed, 50 insertions(+), 13 deletions(-) diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index 600206b..af5b7c7 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -31,7 +31,7 @@ jobs: run: | uv build - uvx twine upload dist/* + uvx twine==6.2.0 upload dist/* deploy-cython: strategy: @@ -43,11 +43,15 @@ jobs: steps: - uses: actions/checkout@v7 - name: Set up Python ${{ matrix.python-version }} + id: setup-python uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} - name: Install uv uses: astral-sh/setup-uv@v10 + - name: Use the matrix interpreter for uv + shell: bash + run: echo "UV_PYTHON=${{ steps.setup-python.outputs.python-path }}" >> "$GITHUB_ENV" - name: Install build dependencies run: | uv venv @@ -59,9 +63,11 @@ jobs: # No build isolation so the Cython installed above is used to build the compiled wheel run: | uv build --wheel --no-build-isolation - uvx twine upload dist/* + uvx twine==6.2.0 upload dist/* - deploy-cython-manylinux: + # Building runs the test suite (third party test dependencies), so it happens in a job without + # access to the PyPI credentials. A separate job only downloads the built wheels and uploads them. + build-cython-manylinux: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7 @@ -70,11 +76,30 @@ jobs: # Build targets and test commands are configured in [tool.cibuildwheel] in pyproject.toml - name: Build wheels - run: uvx cibuildwheel --output-dir dist + run: uvx cibuildwheel==4.3.5 --output-dir dist + + - name: Upload wheel artifact + uses: actions/upload-artifact@v7 + with: + name: python_box_manylinux + path: dist/*-manylinux*.whl + + deploy-cython-manylinux: + needs: build-cython-manylinux + runs-on: ubuntu-latest + steps: + - name: Download wheels + uses: actions/download-artifact@v7 + with: + name: python_box_manylinux + path: dist + + - name: Install uv + uses: astral-sh/setup-uv@v10 - name: Publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: | - uvx twine upload dist/*-manylinux*.whl + uvx twine==6.2.0 upload dist/*-manylinux*.whl diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index f06f154..1627d0e 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -19,9 +19,9 @@ jobs: with: enable-cache: true - name: Ruff lint - run: uvx ruff check . + run: uvx ruff@0.17.3 check . - name: Ruff format - run: uvx ruff format --check . + run: uvx ruff@0.17.3 format --check . package-checks: strategy: @@ -32,6 +32,7 @@ jobs: steps: - uses: actions/checkout@v7 - name: Set up Python ${{ matrix.python-version }} + id: setup-python uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} @@ -39,6 +40,9 @@ jobs: uses: astral-sh/setup-uv@v10 with: enable-cache: true + - name: Use the matrix interpreter for uv + shell: bash + run: echo "UV_PYTHON=${{ steps.setup-python.outputs.python-path }}" >> "$GITHUB_ENV" - name: Install dependencies # Cython is part of the dev group, so the build below produces a compiled wheel run: uv sync --group dev --no-install-project @@ -78,7 +82,7 @@ jobs: enable-cache: true # Build targets and test commands are configured in [tool.cibuildwheel] in pyproject.toml - name: Build wheels - run: uvx cibuildwheel --output-dir dist + run: uvx cibuildwheel==4.3.5 --output-dir dist - name: Upload wheel artifact uses: actions/upload-artifact@v7 @@ -95,6 +99,7 @@ jobs: steps: - uses: actions/checkout@v7 - name: Set up Python ${{ matrix.python-version }} + id: setup-python uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} @@ -102,6 +107,9 @@ jobs: uses: astral-sh/setup-uv@v10 with: enable-cache: true + - name: Use the matrix interpreter for uv + shell: bash + run: echo "UV_PYTHON=${{ steps.setup-python.outputs.python-path }}" >> "$GITHUB_ENV" - name: Install dependencies run: | uv sync --group dev --no-install-project diff --git a/pyproject.toml b/pyproject.toml index 6c46606..7056cc4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -66,7 +66,7 @@ test = [ "pytest-cov<6.0.0", "ruamel.yaml>=0.19.1", "tomli-w>=1.0.0", - "toon_format @ git+https://github.com/toon-format/toon-python.git", + "toon-format>=1.2.0", "types-PyYAML>=6.0.3", ] # Development tooling: linting, type checking, building and releasing @@ -109,7 +109,7 @@ known-first-party = ["box", "test"] [tool.cibuildwheel] build = "cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64 cp315-manylinux_x86_64" # Cython (and setuptools) must be present in the build environment, so build without isolation -before-build = "pip install Cython>=3.3.0 setuptools wheel" +before-build = "pip install 'Cython>=3.3.0' setuptools wheel" build-frontend = { name = "build", args = ["--no-isolation"] } build-verbosity = 1 test-groups = ["test"] diff --git a/uv.lock b/uv.lock index 4bc940d..a0be245 100644 --- a/uv.lock +++ b/uv.lock @@ -1213,7 +1213,7 @@ dev = [ { name = "ruff", specifier = ">=0.17.3" }, { name = "setuptools", specifier = ">=77" }, { name = "tomli-w", specifier = ">=1.0.0" }, - { name = "toon-format", git = "https://github.com/toon-format/toon-python.git" }, + { name = "toon-format", specifier = ">=1.2.0" }, { name = "twine", specifier = ">=5" }, { name = "types-pyyaml", specifier = ">=6.0.3" }, { name = "wheel", specifier = ">=0.34.2" }, @@ -1225,7 +1225,7 @@ test = [ { name = "pytest-cov", specifier = "<6.0.0" }, { name = "ruamel-yaml", specifier = ">=0.19.1" }, { name = "tomli-w", specifier = ">=1.0.0" }, - { name = "toon-format", git = "https://github.com/toon-format/toon-python.git" }, + { name = "toon-format", specifier = ">=1.2.0" }, { name = "types-pyyaml", specifier = ">=6.0.3" }, ] @@ -1445,7 +1445,11 @@ wheels = [ [[package]] name = "toon-format" version = "1.2.0" -source = { git = "https://github.com/toon-format/toon-python.git#536a508d486847cb01ec1869cf21d1f7556b0db0" } +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/06/9e/88b94e00ae3589130bb2bde233c60b55776deb670cc3d077657d6a8b9a2e/toon_format-1.2.0.tar.gz", hash = "sha256:ed09c0cb8ba58f17372f876df1e43400d2d916aef67c641f152d8a28c5898669", size = 20775, upload-time = "2026-10-18T13:23:36.594Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/9e/69331571d5b91b3f34f0dcd7c8135bb3241e41c3c3effb4af8f57772a9ca/toon_format-1.2.0-py3-none-any.whl", hash = "sha256:d94db4b088a281a7bbc85e75d7fbd24e6a0ec7bc110edb129285259eca6522c0", size = 22863, upload-time = "2026-10-18T13:23:35.557Z" }, +] [[package]] name = "twine" From 15a3b14f3d433ea48008a98f3f1149c0ee1e4b31 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:12:50 -0500 Subject: [PATCH 48/61] Pin astral-sh/setup-uv to v10.3.3 commit (no floating v10 tag exists) Co-Authored-By: Claude Opus 5.5 --- .github/workflows/pythonpublish.yml | 8 ++++---- .github/workflows/tests.yml | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index af5b7c7..ff75b12 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -21,7 +21,7 @@ jobs: python-version: '3.15' - name: Install uv - uses: astral-sh/setup-uv@v10 + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 # Isolated build: Cython is not part of the build requirements, so this is the pure Python sdist and wheel - name: Build and Publish @@ -48,7 +48,7 @@ jobs: with: python-version: ${{ matrix.python-version }} - name: Install uv - uses: astral-sh/setup-uv@v10 + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 - name: Use the matrix interpreter for uv shell: bash run: echo "UV_PYTHON=${{ steps.setup-python.outputs.python-path }}" >> "$GITHUB_ENV" @@ -72,7 +72,7 @@ jobs: steps: - uses: actions/checkout@v7 - name: Install uv - uses: astral-sh/setup-uv@v10 + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 # Build targets and test commands are configured in [tool.cibuildwheel] in pyproject.toml - name: Build wheels @@ -95,7 +95,7 @@ jobs: path: dist - name: Install uv - uses: astral-sh/setup-uv@v10 + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 - name: Publish env: diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 1627d0e..5150721 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -15,7 +15,7 @@ jobs: steps: - uses: actions/checkout@v7 - name: Install uv - uses: astral-sh/setup-uv@v10 + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: enable-cache: true - name: Ruff lint @@ -37,7 +37,7 @@ jobs: with: python-version: ${{ matrix.python-version }} - name: Install uv - uses: astral-sh/setup-uv@v10 + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: enable-cache: true - name: Use the matrix interpreter for uv @@ -77,7 +77,7 @@ jobs: steps: - uses: actions/checkout@v7 - name: Install uv - uses: astral-sh/setup-uv@v10 + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: enable-cache: true # Build targets and test commands are configured in [tool.cibuildwheel] in pyproject.toml @@ -104,7 +104,7 @@ jobs: with: python-version: ${{ matrix.python-version }} - name: Install uv - uses: astral-sh/setup-uv@v10 + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: enable-cache: true - name: Use the matrix interpreter for uv From bd2d950e03e168751bb7a3195f49589dbde365ab Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 21:19:57 -0500 Subject: [PATCH 49/61] CI: pass setup-python interpreter to uv sync/venv instead of exporting UV_PYTHON Exporting UV_PYTHON made uv build / uv pip target the bare interpreter rather than the project .venv, so --no-build-isolation builds could not find setuptools. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/pythonpublish.yml | 5 +---- .github/workflows/tests.yml | 10 ++-------- 2 files changed, 3 insertions(+), 12 deletions(-) diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index ff75b12..ce902de 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -49,12 +49,9 @@ jobs: python-version: ${{ matrix.python-version }} - name: Install uv uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 - - name: Use the matrix interpreter for uv - shell: bash - run: echo "UV_PYTHON=${{ steps.setup-python.outputs.python-path }}" >> "$GITHUB_ENV" - name: Install build dependencies run: | - uv venv + uv venv --python "${{ steps.setup-python.outputs.python-path }}" uv pip install "setuptools>=77" wheel "Cython>=3.3.0" - name: Build and publish env: diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 5150721..b92442d 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -40,12 +40,9 @@ jobs: uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: enable-cache: true - - name: Use the matrix interpreter for uv - shell: bash - run: echo "UV_PYTHON=${{ steps.setup-python.outputs.python-path }}" >> "$GITHUB_ENV" - name: Install dependencies # Cython is part of the dev group, so the build below produces a compiled wheel - run: uv sync --group dev --no-install-project + run: uv sync --python "${{ steps.setup-python.outputs.python-path }}" --group dev --no-install-project - name: Run mypy if: "!startsWith(matrix.python-version, 'pypy')" run: uv run --no-sync mypy box @@ -107,12 +104,9 @@ jobs: uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: enable-cache: true - - name: Use the matrix interpreter for uv - shell: bash - run: echo "UV_PYTHON=${{ steps.setup-python.outputs.python-path }}" >> "$GITHUB_ENV" - name: Install dependencies run: | - uv sync --group dev --no-install-project + uv sync --python "${{ steps.setup-python.outputs.python-path }}" --group dev --no-install-project # Editable install without build isolation compiles box in place using the Cython from the dev group uv pip install -e . --no-build-isolation - name: Test with pytest From ba1dac002bc498da1f1606ab2f78b0127cd7336a Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 22:26:05 -0500 Subject: [PATCH 50/61] Fix #321 review issues: convert only numbers and bools, handle anchored booleans and keys The submitted conversion turned anchored booleans (ruamel ScalarBoolean, not an int subclass in the bool sense) into int 1, and converted ruamel string types to str, which dropped literal block style and preserved quotes on to_yaml. Strings are now left untouched, ScalarBoolean maps to bool, and mapping keys are converted too. Co-Authored-By: Claude Opus 5.5 --- box/converters.py | 19 +++++++++++-------- test/test_box.py | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+), 8 deletions(-) diff --git a/box/converters.py b/box/converters.py index 00c7c14..f14e118 100644 --- a/box/converters.py +++ b/box/converters.py @@ -241,27 +241,30 @@ def _to_yaml( raise BoxError(MISSING_PARSER_ERROR) - def _ruamel_to_builtin(obj): - """Convert ruamel.yaml scalar types to plain Python builtins. + """Convert ruamel.yaml numeric and boolean scalar types to plain Python builtins. ScalarFloat/ScalarInt survive Box.to_dict() and break serializers that only accept builtin float/int (issue #264). + + Only numbers and booleans are converted. ruamel string types (literal and folded + blocks, quoted strings) are left alone so to_yaml keeps their formatting, and + ScalarBoolean (used for anchored booleans) is not an int subclass, so it is checked + explicitly rather than falling through to int. """ if isinstance(obj, dict): - return {k: _ruamel_to_builtin(v) for k, v in obj.items()} + return {_ruamel_to_builtin(k): _ruamel_to_builtin(v) for k, v in obj.items()} if isinstance(obj, list): return [_ruamel_to_builtin(v) for v in obj] - module = type(obj).__module__ - if module.startswith("ruamel"): - if isinstance(obj, bool): + if type(obj).__module__.startswith("ruamel"): + from ruamel.yaml.scalarbool import ScalarBoolean + + if isinstance(obj, (bool, ScalarBoolean)): return bool(obj) if isinstance(obj, int): return int(obj) if isinstance(obj, float): return float(obj) - if isinstance(obj, str): - return str(obj) return obj diff --git a/test/test_box.py b/test/test_box.py index 066d9fc..b447061 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -2315,3 +2315,38 @@ def test_create_on_get_default_unchanged(self): def test_no_default_box_unchanged(self): with pytest.raises(BoxKeyError): Box().x.y = 1 + + +class TestRuamelScalarConversion: + """from_yaml returns builtin numbers and bools without disturbing strings (#264, PR #321).""" + + def test_anchored_boolean_stays_bool(self): + bx = Box.from_yaml("a: &x true\nb: *x\nc: false\n") + assert bx.a is True and bx.b is True and bx.c is False + + def test_anchored_boolean_round_trips_as_bool(self): + assert Box.from_yaml("a: &x true\nb: *x\n").to_yaml() == "a: true\nb: true\n" + assert Box.from_yaml("a: &x true\n").to_json() == '{"a": true}' + + def test_multiline_string_dump_unchanged(self): + bx = Box.from_yaml("lit: |\n line1\n line2\n") + assert bx.to_yaml() == "lit: |\n line1\n line2\n" + + def test_preserve_quotes_attr_still_effective(self): + bx = Box.from_yaml("a: 'x'\n", ruamel_attrs={"preserve_quotes": True}) + assert bx.to_yaml() == "a: 'x'\n" + + def test_numbers_become_builtin(self): + bx = Box.from_yaml("f: 1.10\ni: 0x1F\nu: 1_000\no: 0o17\nb: 0b101\n") + assert [type(v) for v in bx.values()] == [float, int, int, int, int] + + def test_keys_are_builtin(self): + bx = Box.from_yaml("1.5: a\n", conversion_box=False) + assert [type(k) for k in bx.keys()] == [float] + + def test_pyyaml_backend_unaffected(self, monkeypatch): + import box.converters as cv + + monkeypatch.setattr(cv, "ruamel_available", False) + bx = Box.from_yaml("a: 1.10\nb: true\n") + assert bx.to_dict() == {"a": 1.1, "b": True} From d472d74bf08d512906498656455de86acc35b902 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 22:28:36 -0500 Subject: [PATCH 51/61] Skip the PyYAML backend test when PyYAML is not installed (cibuildwheel env) Co-Authored-By: Claude Opus 5.5 --- test/test_box.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/test_box.py b/test/test_box.py index b447061..d06ae31 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -2347,6 +2347,8 @@ def test_keys_are_builtin(self): def test_pyyaml_backend_unaffected(self, monkeypatch): import box.converters as cv + if not cv.pyyaml_available: + pytest.skip("PyYAML is not installed") monkeypatch.setattr(cv, "ruamel_available", False) bx = Box.from_yaml("a: 1.10\nb: true\n") assert bx.to_dict() == {"a": 1.1, "b": True} From a5aeaf28e45c3c23a66fc0d62e5697e0f30bf449 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 22:40:46 -0500 Subject: [PATCH 52/61] Rework #314: case-insensitive ConfigBox keys where the latest write wins The PR as submitted crashed on non-string keys, silently merged keys that differ only by case into the first spelling, made update and merge_update disagree, and scanned every key on each miss. * Only str keys are matched ignoring case, other keys match exactly * A ConfigBox never holds two keys differing only by case: the latest write wins, keeping its value and its spelling (construction, [] and attribute assignment, update, merge_update and |) * Lookups, in, del, pop, get and box_dots paths (first segment, nested ConfigBoxes match the rest) all resolve case-insensitively * A lower-case index in the box config makes misses O(1). It is rebuilt when the dict size changes behind ConfigBox's back * A stale default_box ephemeral child is not attached when the key was since assigned under a different spelling * Frozen ConfigBoxes still refuse every write Co-Authored-By: Claude Opus 5.5 --- CHANGES.rst | 2 + box/config_box.py | 219 ++++++++++++++++++++++++++++------ box/config_box.pyi | 1 - test/test_config_box_case.py | 222 +++++++++++++++++++++++++++++++++++ 4 files changed, 410 insertions(+), 34 deletions(-) create mode 100644 test/test_config_box_case.py diff --git a/CHANGES.rst b/CHANGES.rst index 241a68a..a513061 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -10,12 +10,14 @@ Breaking changes * Removing support for Python 3.10 as it is EOL, Python 3.11+ is now required * merge_update now raises BoxValueError for an unrecognized box_merge_lists value instead of silently replacing the list * Box.copy() / copy.copy() / copy.deepcopy() now return the same class as the original (subclasses of Box, ConfigBox, SBox and DDBox were previously turned into a plain Box / ConfigBox / SBox) +* ConfigBox string keys are now case-insensitive for every kind of access (not only attribute lookups), and a ConfigBox no longer holds keys that differ only by case: the latest write wins, keeping its value and spelling, so ConfigBox({'Foo': 1, 'foo': 2}) is ConfigBox({'foo': 2}) * Build and development tooling changed (see below): installing from an sdist now needs setuptools>=77, and building the Cython version from source requires --no-build-isolation Changes * Fixing #274 default_box_create_on_get=False not creating missing parent keys on assignment, e.g. box.a.b = 1 (thanks to gyanu2507 for the fix and wrdls for reporting) * Adding #263 "merge" option for box_merge_lists to merge lists of dictionaries element by element (thanks to ChrisJr404) +* Adding #314 case-insensitive ConfigBox keys for [] access, in, del, update, merge_update and box_dots paths, matching configparser (thanks to binggao1230) * Adding #269 internal-only attributes for Box subclasses via _box_internal_attrs (thanks to bwanshoom and gtkacz for the suggestion) * Adding support for Python 3.15 * Adding manylinux Cython wheels for Python 3.14 and 3.15 diff --git a/box/config_box.py b/box/config_box.py index f3e8834..705938b 100644 --- a/box/config_box.py +++ b/box/config_box.py @@ -2,7 +2,8 @@ # -*- coding: utf-8 -*- from __future__ import annotations -from box.box import Box +from box.box import Box, _parse_box_dots +from box.exceptions import BoxError, BoxTypeError class ConfigBox(Box): @@ -16,56 +17,208 @@ class ConfigBox(Box): cns.bool('my_bool') # True cns.int('my_int') # 5 cns.list('my_list', mod=lambda x: int(x)) # [5, 4, 3, 3, 2] + + String keys are case-insensitive, like configparser options. Lookups, ``in``, + deletion and attribute access find a key whatever its case: + + cns = ConfigBox(HOST='localhost') + cns.host, cns['Host'], 'host' in cns # 'localhost', 'localhost', True + + A ConfigBox never holds two keys that differ only by case. Writing a key that + matches an existing one replaces it, and the latest write always wins: both its + value and its spelling are kept, and the key moves to the end like a new key. + + ConfigBox({'Foo': 1, 'foo': 2}) # ConfigBox({'foo': 2}) + + Only ``str`` keys are matched this way, other keys must match exactly. """ _protected_keys = dir(Box) + ["bool", "int", "float", "list", "getboolean", "getfloat", "getint"] - @staticmethod - def _case_insensitive_key(keys, item): - """Return a matching key (case-insensitive) from *keys*, or *item* if no match.""" - lower = item.lower() - for k in keys: - if k.lower() == lower: - return k - return item + # Case-insensitive key matching. + # + # `__ci_index` in the box config maps key.lower() to the stored key, so a miss costs a dict + # lookup rather than a scan of every key. `__ci_len` is the dict size the index was last in + # sync with. Writes and deletes made through ConfigBox keep the index current. Any other + # write (Box internals storing directly on the dict) changes the size, which makes the next + # lookup rebuild the index. + + def _ci_index(self): + config = self._box_config + index = config.get("__ci_index") + if index is None or config.get("__ci_len") != dict.__len__(self): + index = {} + for key in dict.keys(self): + if isinstance(key, str): + index[key.lower()] = key + config["__ci_index"] = index + config["__ci_len"] = dict.__len__(self) + return index + + def _ci_key(self, key): + """Return the stored key equal to `key` ignoring case, or None. Only str keys are matched.""" + if not isinstance(key, str): + return None + if dict.__contains__(self, key): + return key + found = self._ci_index().get(key.lower()) + if found is not None and dict.__contains__(self, found): + return found + return None + + def _ci_resolve(self, key): + """Return the key to use for `key`: the stored spelling if one matches, `key` otherwise.""" + if not isinstance(key, str) or dict.__contains__(self, key): + return key + found = self._ci_key(key) + if found is not None: + return found + config = self._box_config + if config["box_dots"] and ("." in key or "[" in key): + if config["box_dots_exclude"] and config["box_dots_exclude"].match(key): + return key + # Match the first segment of a dotted path, nested ConfigBoxes match the rest + try: + first, rest = _parse_box_dots(self, key) + except BoxError: + return key + found = self._ci_key(first) + if found is not None and found != first: + return f"{found}{rest}" if rest.startswith("[") else f"{found}.{rest}" + return key - def __getattr__(self, item): + def _ci_after_write(self, key, len_before, was_present): + """Update the index after `key` was written or deleted through ConfigBox.""" + config = self._box_config + index = config.get("__ci_index") + if index is None: + return + if config.get("__ci_len") != len_before: + config["__ci_index"] = None + return + present = dict.__contains__(self, key) + if isinstance(key, str): + lowered = key.lower() + if present: + index[lowered] = key + elif index.get(lowered) == key: + del index[lowered] + expected = len_before + int(present and not was_present) - int(was_present and not present) + if dict.__len__(self) == expected: + config["__ci_len"] = expected + else: + # Something besides `key` changed (for example a dotted write), rebuild on next use + config["__ci_index"] = None + + def _ci_check_frozen(self): + if self._box_config["frozen_box"] and self._box_config["__created"]: + raise BoxError("Box is frozen") + + def _ci_take_over(self, key, keep_value=False): """ - Config file keys are stored in lower case, be a little more - loosey goosey + Remove a stored key that differs from `key` only by case, so `key` replaces it. + With keep_value its value is stored again under the new spelling. """ - try: - return super().__getattr__(item) - except AttributeError: - # Try case-insensitive match across all keys, not just lowering input - matched = self._case_insensitive_key(self.keys(), item) - if matched != item: - return super().__getattr__(matched) - raise + existing = self._ci_key(key) + if existing is None or existing == key: + return + self._ci_check_frozen() + value = dict.__getitem__(self, existing) + len_before = dict.__len__(self) + dict.__delitem__(self, existing) + if self._box_config["conversion_box"]: + safe_keys = self._box_config["__safe_keys"] + safe_key = self._safe_attr(existing) + if safe_keys.get(safe_key) == existing: + del safe_keys[safe_key] + self._ci_after_write(existing, len_before, True) + if keep_value: + len_before = dict.__len__(self) + if self._box_config["conversion_box"]: + self._box_config["__safe_keys"][self._safe_attr(key)] = key + dict.__setitem__(self, key, value) + self._ci_after_write(key, len_before, False) def __getitem__(self, item, _ignore_default=False): - try: - return super().__getitem__(item, _ignore_default=_ignore_default) - except KeyError: - matched = self._case_insensitive_key(self.keys(), item) - if matched != item: - return super().__getitem__(matched, _ignore_default=_ignore_default) - raise + return super().__getitem__(self._ci_resolve(item), _ignore_default=_ignore_default) def __contains__(self, item): if super().__contains__(item): return True - return self._case_insensitive_key(self.keys(), item) != item + resolved = self._ci_resolve(item) + return resolved != item and super().__contains__(resolved) def __setitem__(self, key, value): - matched = self._case_insensitive_key(self.keys(), key) - if matched != key: - key = matched + if key != "_box_config": + self._ci_check_frozen() + if isinstance(key, str) and not dict.__contains__(self, key): + resolved = self._ci_resolve(key) + if resolved != key and not dict.__contains__(self, resolved): + # Dotted path whose first segment matched, the nested box handles the rest + key = resolved + else: + self._ci_take_over(key) + len_before = dict.__len__(self) + was_present = dict.__contains__(self, key) super().__setitem__(key, value) + self._ci_after_write(key, len_before, was_present) def __delitem__(self, key): - matched = self._case_insensitive_key(self.keys(), key) - super().__delitem__(matched) + key = self._ci_resolve(key) + len_before = dict.__len__(self) + was_present = dict.__contains__(self, key) + super().__delitem__(key) + self._ci_after_write(key, len_before, was_present) + + def update(self, *args, **kwargs): + if self._box_config["frozen_box"]: + raise BoxError("Box is frozen") + if len(args) > 1: + raise BoxTypeError(f"update expected at most 1 argument, got {len(args)}") + pairs = [] + single_arg = next(iter(args), None) + if single_arg: + if hasattr(single_arg, "keys"): + pairs.extend((k, single_arg[k]) for k in single_arg) + else: + pairs.extend(single_arg) + pairs.extend(kwargs.items()) + # One pair at a time so a later spelling of the same key replaces an earlier one + for k, v in pairs: + self._ci_take_over(k) + len_before = dict.__len__(self) + was_present = dict.__contains__(self, k) + super().update(((k, v),)) + self._ci_after_write(k, len_before, was_present) + + def merge_update(self, *args, **kwargs): + # Give existing keys the incoming spelling first, so the merge itself then matches exactly + if not kwargs.get("_force_unfrozen"): + self._ci_check_frozen() + if len(args) == 1 and args[0]: + if hasattr(args[0], "keys"): + incoming = list(args[0].keys()) + else: + args = (list(args[0]),) # may be a one-shot iterator, it is read twice + incoming = [k for k, _ in args[0]] + else: + incoming = [] + incoming.extend(k for k in kwargs if k not in ("box_merge_lists", "_force_unfrozen")) + for k in incoming: + self._ci_take_over(k, keep_value=True) + return super().merge_update(*args, **kwargs) + + def _flush_pending_parent(self): + pending = self._box_config.get("__pending_parent") + if pending is not None: + parent, key = pending + if isinstance(parent, ConfigBox) and parent._ci_key(key) not in (None, key): + # The key was given a value (under another spelling) since this child was handed + # out, so the child is stale and is not attached. Ancestors still are, like Box. + self._box_config.pop("__pending_parent", None) + parent._flush_pending_parent() + return + super()._flush_pending_parent() def __dir__(self) -> list[str]: return super().__dir__() + ["bool", "int", "float", "list", "getboolean", "getfloat", "getint"] diff --git a/box/config_box.pyi b/box/config_box.pyi index b8bff36..05fe00a 100644 --- a/box/config_box.pyi +++ b/box/config_box.pyi @@ -4,7 +4,6 @@ from typing import Any from box.box import Box as Box class ConfigBox(Box): - def __getattr__(self, item: Any): ... def __dir__(self) -> list[str]: ... def bool(self, item: Any, default: Any | None = ...): ... def int(self, item: Any, default: Any | None = ...): ... diff --git a/test/test_config_box_case.py b/test/test_config_box_case.py new file mode 100644 index 0000000..95f5f9c --- /dev/null +++ b/test/test_config_box_case.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""ConfigBox string keys are case-insensitive and the latest write wins (#314).""" + +import copy +import pickle +import time + +import pytest + +from box import Box, BoxError, ConfigBox + + +class TestConfigBoxCaseInsensitive: + def test_lookup_any_case(self): + cb = ConfigBox({"HOST": "localhost", "ServerPort": 8080}) + assert cb["host"] == cb["Host"] == cb.host == cb.HOST == "localhost" + assert cb.serverport == cb["SERVERPORT"] == 8080 + assert "host" in cb and "serverPORT" in cb and "nope" not in cb + assert cb.get("host") == "localhost" + assert cb.get("nope", 5) == 5 + + def test_transforms_any_case(self): + cb = ConfigBox({"Flag": "yes", "Count": "5", "Ratio": "1.5", "Items": "a, b"}) + assert cb.bool("flag") is True + assert cb.int("COUNT") == 5 + assert cb.getfloat("ratio") == 1.5 + assert cb.list("items") == ["a", "b"] + + def test_latest_write_wins_on_construction(self): + assert ConfigBox({"Foo": 1, "foo": 2}).to_dict() == {"foo": 2} + assert ConfigBox({"Foo": 1, "foo": 2, "FOO": 3}).to_dict() == {"FOO": 3} + assert ConfigBox(A=1, a=2).to_dict() == {"a": 2} + assert ConfigBox.from_json('{"Foo": 1, "foo": 2}').to_dict() == {"foo": 2} + + def test_latest_write_wins_on_assignment(self): + cb = ConfigBox({"host": "a", "port": 1}) + cb["HOST"] = "b" + assert cb.to_dict() == {"port": 1, "HOST": "b"} + cb.Host = "c" + assert cb.to_dict() == {"port": 1, "Host": "c"} + cb.Host = "d" # same spelling replaces in place + assert list(cb.keys()) == ["port", "Host"] + assert cb.host == "d" + + def test_update_and_merge_update_agree(self): + for method in ("update", "merge_update"): + cb = ConfigBox({"Host": "h", "port": 1}) + getattr(cb, method)({"HOST": "u"}) + assert cb.to_dict() == {"port": 1, "HOST": "u"}, method + getattr(cb, method)(host="v") + assert cb.to_dict() == {"port": 1, "host": "v"}, method + getattr(cb, method)([("Host", "w")]) + assert cb.to_dict() == {"port": 1, "Host": "w"}, method + cb = ConfigBox() + cb.update({"a": 1, "A": 2}) + assert cb.to_dict() == {"A": 2} + + def test_merge_update_merges_nested_and_takes_spelling(self): + cb = ConfigBox({"Server": {"host": "h", "port": 1}}) + cb.merge_update({"SERVER": {"PORT": 2}}) + assert cb.to_dict() == {"SERVER": {"host": "h", "PORT": 2}} + assert cb.server.port == 2 + cb.merge_update(iter([("server", {"x": 1})])) # one-shot iterators are only consumed once + assert cb.to_dict() == {"server": {"host": "h", "PORT": 2, "x": 1}} + + def test_union_right_side_wins(self): + assert (ConfigBox({"Foo": 1, "bar": 2}) | {"FOO": 3}).to_dict() == {"bar": 2, "FOO": 3} + + def test_delete_and_pop_any_case(self): + cb = ConfigBox({"HOST": 1, "Port": 2, "user": 3}) + del cb["host"] + assert cb.pop("PORT") == 2 + del cb.USER + assert cb.to_dict() == {} + assert "host" not in cb + with pytest.raises(KeyError): + del cb["host"] + + def test_setdefault_keeps_existing(self): + cb = ConfigBox({"Host": "h"}) + assert cb.setdefault("host", "x") == "h" + assert cb.to_dict() == {"Host": "h"} + + def test_popitem_and_clear_keep_index_in_sync(self): + cb = ConfigBox({"A": 1, "B": 2}) + assert cb.popitem() == ("B", 2) + assert "b" not in cb and "a" in cb + cb.clear() + assert "a" not in cb + cb["A"] = 1 + assert cb.a == 1 + + @pytest.mark.parametrize("key", [1, None, (1, 2), 1.5, b"Bytes"]) + def test_non_string_keys_match_exactly(self, key): + cb = ConfigBox({key: "v"}) + assert cb[key] == "v" + assert key in cb + assert 999 not in cb + del cb[key] + assert key not in cb + assert b"bytes" not in ConfigBox({b"Bytes": 1}) + + def test_missing_keys_raise_keyerror(self): + with pytest.raises(KeyError): + ConfigBox({"a": 1})[5] + with pytest.raises(KeyError): + ConfigBox({"a": 1})["b"] + with pytest.raises(AttributeError): + ConfigBox({"a": 1}).b + + def test_unhashable_in_raises_typeerror_like_dict(self): + with pytest.raises(TypeError): + [] in ConfigBox({"a": 1}) + + def test_mixed_str_and_non_str_keys(self): + cb = ConfigBox({1: "one", "One": "word"}) + cb["ONE"] = "WORD" + assert cb.to_dict() == {1: "one", "ONE": "WORD"} + + def test_box_duplicates_error_still_raises(self): + with pytest.raises(BoxError): + ConfigBox({"a_b": 1, "a b": 2}, box_duplicates="error") + # A different case is replaced rather than reported as a duplicate + assert ConfigBox({"A_B": 1, "a_b": 2}, box_duplicates="error").to_dict() == {"a_b": 2} + + def test_conversion_alias_follows_new_spelling(self): + cb = ConfigBox({"My Key": 1}) + assert cb.My_Key == 1 + cb["my key"] = 2 + assert cb.my_key == 2 + assert cb.to_dict() == {"my key": 2} + + def test_nested_boxes_are_case_insensitive(self): + cb = ConfigBox({"Database": {"Host": "h"}}) + assert isinstance(cb.database, ConfigBox) + assert cb.DATABASE.host == "h" + cb.database.HOST = "x" + assert cb.to_dict() == {"Database": {"HOST": "x"}} + + def test_box_dots_any_case(self): + cb = ConfigBox({"Server": {"Host": "h", "Ports": [1, 2]}}, box_dots=True) + assert cb["server.host"] == "h" + assert cb["SERVER.ports[1]"] == 2 + assert "server.HOST" in cb + cb["server.host"] = "x" + assert cb.to_dict() == {"Server": {"host": "x", "Ports": [1, 2]}} + del cb["SERVER.HOST"] + assert cb.to_dict() == {"Server": {"Ports": [1, 2]}} + + def test_box_dots_literal_dotted_key(self): + cb = ConfigBox({"A.B": 1}, box_dots=True, box_dots_exclude=r"(?i)a\.b") + assert cb["a.b"] == 1 + cb["a.b"] = 2 + assert cb.to_dict() == {"a.b": 2} + + def test_default_box_any_case(self): + cb = ConfigBox({"Host": "h"}, default_box=True) + assert cb.host == "h" + cb.HOST = "x" + assert cb.to_dict() == {"HOST": "x"} + + def test_default_box_created_key_found_any_case(self): + cb = ConfigBox(default_box=True) + cb.Section.Key = 1 + assert cb.section.key == 1 + assert cb.to_dict() == {"Section": {"Key": 1}} + + def test_stale_ephemeral_child_is_not_attached(self): + cb = ConfigBox(default_box=True, default_box_create_on_get=False) + child = cb.Section + cb["SECTION"] = {"a": 1} + child.b = 2 + assert cb.to_dict() == {"SECTION": {"a": 1}} + + def test_frozen(self): + cb = ConfigBox({"Host": "h", "host": "x"}, frozen_box=True) + assert cb.to_dict() == {"host": "x"} + assert cb.HOST == "x" + for action in ( + lambda: cb.__setitem__("HOST", 1), + lambda: cb.update(HOST=1), + lambda: cb.merge_update(HOST=1), + lambda: cb.__delitem__("HOST"), + ): + with pytest.raises(BoxError): + action() + assert cb.to_dict() == {"host": "x"} + + def test_copy_pickle_round_trip(self): + cb = ConfigBox({"Host": "h", "Nested": {"Key": 1}}) + for other in (cb.copy(), copy.deepcopy(cb), pickle.loads(pickle.dumps(cb))): + assert type(other) is ConfigBox + assert other.host == "h" and other.nested.key == 1 + other["HOST"] = "x" + assert other.to_dict() == {"Nested": {"Key": 1}, "HOST": "x"} + assert cb.to_dict() == {"Host": "h", "Nested": {"Key": 1}} + + def test_plain_box_unchanged(self): + bx = Box({"Foo": 1, "foo": 2}) + assert bx.to_dict() == {"Foo": 1, "foo": 2} + with pytest.raises(KeyError): + bx["FOO"] + + def test_index_survives_direct_dict_writes(self): + cb = ConfigBox({"a": 1}) + assert "A" in cb + dict.__setitem__(cb, "New", 2) # bypasses ConfigBox, as some Box internals do + assert cb.new == 2 + + def test_large_box_misses_and_construction_are_fast(self): + start = time.perf_counter() + cb = ConfigBox({f"Key{i}": i for i in range(20000)}) + built = time.perf_counter() - start + start = time.perf_counter() + for _ in range(2000): + assert "nope" not in cb + assert cb.get("KEY19999") == 19999 + lookups = time.perf_counter() - start + # Generous limits: a scan of every key per miss takes seconds here, quadratic construction minutes + assert built < 5 + assert lookups < 1 From a7aaa6a0a2ba911e15514e097c82444320780a69 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Tue, 3 Nov 2026 22:56:50 -0500 Subject: [PATCH 53/61] 8.0.0 features: create_on_get off by default, subclass defaults, YAML key order, camel keep keys, int keys in dotted paths * #262 default_box_create_on_get now defaults to False, so attribute probing (IPython, Spyder, hasattr) never adds keys. pop() of a missing key and hasattr + delattr (argparse namespaces) keep working with it. * #296 / #223 / #210 _box_defaults class attribute: subclasses change option defaults without overriding __init__. Options are now read from kwargs in one place (_build_box_config), so an explicit option still wins. DDBox uses it. * #104 to_yaml keeps insertion order for PyYAML and ruamel safe / unsafe too, sort_keys=True sorts. * #279 camel_killer_box_keep_keys keeps CamelCase keys and adds snake_case attribute aliases through conversion_box. * #123 box_dots path segments made of digits also match int keys. Only for path segments, a str key of the same value wins, plain keys are not mapped. Co-Authored-By: Claude Opus 5.5 --- CHANGES.rst | 8 ++ box/box.py | 232 ++++++++++++++++++++++---------------- box/box.pyi | 3 + box/box_list.py | 1 + box/converters.py | 56 +++++---- box/converters.pyi | 1 + box/shorthand_box.py | 13 +-- test/test_box.py | 61 ++++++++-- test/test_box_defaults.py | 94 +++++++++++++++ test/test_box_keys_8.py | 119 +++++++++++++++++++ test/test_yaml_order.py | 43 +++++++ 11 files changed, 488 insertions(+), 143 deletions(-) create mode 100644 test/test_box_defaults.py create mode 100644 test/test_box_keys_8.py create mode 100644 test/test_yaml_order.py diff --git a/CHANGES.rst b/CHANGES.rst index a513061..759bcc2 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -11,6 +11,10 @@ Breaking changes * merge_update now raises BoxValueError for an unrecognized box_merge_lists value instead of silently replacing the list * Box.copy() / copy.copy() / copy.deepcopy() now return the same class as the original (subclasses of Box, ConfigBox, SBox and DDBox were previously turned into a plain Box / ConfigBox / SBox) * ConfigBox string keys are now case-insensitive for every kind of access (not only attribute lookups), and a ConfigBox no longer holds keys that differ only by case: the latest write wins, keeping its value and spelling, so ConfigBox({'Foo': 1, 'foo': 2}) is ConfigBox({'foo': 2}) +* default_box_create_on_get now defaults to False (#262): looking up a missing key returns the default without storing it, so tools that probe attributes (IPython, Spyder) no longer add keys. Assigning through a missing key still creates it (box.a.b = 1). Changing a default value in place, such as box.tags.append(1) with default_box_attr=[], is no longer kept, pass default_box_create_on_get=True for the old behavior (thanks to wtld for reporting) +* to_yaml writes keys in insertion order with PyYAML and the ruamel safe / unsafe dumpers too (the default ruamel round trip dumper already did), pass sort_keys=True to sort them (#104, thanks to philipsd6 for reporting) +* Box options are no longer named parameters of Box.__new__ / Box.__init__, they are read from keyword arguments (behavior is the same, the type stubs still list them) +* DDBox options can now be overridden, e.g. DDBox(default_box=False) * Build and development tooling changed (see below): installing from an sdist now needs setuptools>=77, and building the Cython version from source requires --no-build-isolation Changes @@ -18,6 +22,10 @@ Changes * Fixing #274 default_box_create_on_get=False not creating missing parent keys on assignment, e.g. box.a.b = 1 (thanks to gyanu2507 for the fix and wrdls for reporting) * Adding #263 "merge" option for box_merge_lists to merge lists of dictionaries element by element (thanks to ChrisJr404) * Adding #314 case-insensitive ConfigBox keys for [] access, in, del, update, merge_update and box_dots paths, matching configparser (thanks to binggao1230) +* Adding #296 _box_defaults class attribute so subclasses can change Box option defaults without overriding __init__ (also #223, #210, thanks to marcelloromani, 12rambau and miversen33 for reporting) +* Adding #279 camel_killer_box_keep_keys to keep the original CamelCase keys and only add snake_case attribute aliases (thanks to jacobtomlinson for the suggestion) +* Adding #123 box_dots path segments made of digits also match integer keys, e.g. box['servers.2'] for {'servers': {2: ...}} (thanks to richieadler for reporting) +* Fixing Box(default_box=True) pop() of a missing key and argparse namespaces (hasattr then delattr) with default_box_create_on_get=False * Adding #269 internal-only attributes for Box subclasses via _box_internal_attrs (thanks to bwanshoom and gtkacz for the suggestion) * Adding support for Python 3.15 * Adding manylinux Cython wheels for Python 3.14 and 3.15 diff --git a/box/box.py b/box/box.py index c2e6655..3f0b80d 100644 --- a/box/box.py +++ b/box/box.py @@ -15,7 +15,7 @@ from inspect import signature from keyword import iskeyword from os import PathLike -from typing import Any, Literal +from typing import Any import box from box.converters import ( @@ -157,6 +157,49 @@ def _get_box_config(): } +#: Every Box option and its default. Subclasses can change these defaults with ``_box_defaults``. +BOX_OPTION_DEFAULTS: dict[str, Any] = { + "default_box": False, + "default_box_attr": NO_DEFAULT, + "default_box_none_transform": True, + "default_box_create_on_get": False, + "frozen_box": False, + "camel_killer_box": False, + "camel_killer_box_keep_keys": False, + "conversion_box": True, + "modify_tuples_box": False, + "box_safe_prefix": "x", + "box_duplicates": "ignore", + "box_intact_types": (), + "box_recast": None, + "box_dots": False, + "box_dots_exclude": None, + "box_class": None, + "box_namespace": (), +} + + +def _build_box_config(cls, kwargs: dict) -> dict: + """ + Build the box config for `cls`, removing the Box options from `kwargs` so only data keys remain. + + An option passed explicitly wins, then the class ``_box_defaults``, then ``BOX_OPTION_DEFAULTS``. + """ + options = {**BOX_OPTION_DEFAULTS, **cls._box_resolved_defaults} + for name in BOX_OPTION_DEFAULTS: + if name in kwargs: + options[name] = kwargs.pop(name) + config = _get_box_config() + config.update(options) + if config["default_box_attr"] is NO_DEFAULT: + config["default_box_attr"] = cls + if config["box_class"] is None: + config["box_class"] = cls + config["box_intact_types"] = tuple(config["box_intact_types"]) + config["box_dots_exclude"] = re.compile(config["box_dots_exclude"]) if config["box_dots_exclude"] else None + return config + + def _get_property_func(obj, key): """ Try to get property helper functions of given object and property name. @@ -181,9 +224,12 @@ class Box(dict): :param default_box_attr: Specify the default replacement. WARNING: If this is not the default 'Box', it will not be recursive :param default_box_none_transform: When using default_box, treat keys with none values as absent. True by default - :param default_box_create_on_get: On lookup of a key that doesn't exist, create it if missing + :param default_box_create_on_get: On lookup of a key that doesn't exist, also store the default value. + False by default: lookups never change the Box, assigning through a missing key still creates it :param frozen_box: After creation, the box cannot be modified :param camel_killer_box: Convert CamelCase to snake_case + :param camel_killer_box_keep_keys: With camel_killer_box, keep the original keys and only add + snake_case attribute aliases for them (needs conversion_box) :param conversion_box: Check for near matching keys as attributes :param modify_tuples_box: Recreate incoming tuples with dicts into Boxes :param box_safe_prefix: Conversion box prefix for unsafe attributes @@ -207,6 +253,12 @@ class Box(dict): #: exported, iterated, compared or hashed. See the "Internal Attributes" docs. _box_internal_attrs: tuple[str, ...] = () + #: Box options this class uses when they are not passed explicitly, for example + #: ``_box_defaults = {"default_box": True}``. Subclasses inherit and extend them. + #: See the "Subclassing Box" docs. + _box_defaults: dict[str, Any] = {} + _box_resolved_defaults: dict[str, Any] = {} + _protected_keys = [ "to_dict", "to_json", @@ -218,104 +270,40 @@ class Box(dict): "merge_update", ] + [attr for attr in dir({}) if not attr.startswith("_")] - def __new__( - cls, - *args: Any, - default_box: bool = False, - default_box_attr: Any = NO_DEFAULT, - default_box_none_transform: bool = True, - default_box_create_on_get: bool = True, - frozen_box: bool = False, - camel_killer_box: bool = False, - conversion_box: bool = True, - modify_tuples_box: bool = False, - box_safe_prefix: str = "x", - box_duplicates: str = "ignore", - box_intact_types: tuple | list = (), - box_recast: dict | None = None, - box_dots: bool = False, - box_dots_exclude: str | None = None, - box_class: dict | type[Box] | None = None, - box_namespace: tuple[str, ...] | Literal[False] = (), - **kwargs: Any, - ): + def __init_subclass__(cls, **kwargs): + super().__init_subclass__(**kwargs) + own = cls.__dict__.get("_box_defaults", {}) + unknown = sorted(set(own) - set(BOX_OPTION_DEFAULTS)) + if unknown: + raise BoxError(f"Unknown Box options in {cls.__name__}._box_defaults: {', '.join(unknown)}") + # Merged along the inheritance chain, so a subclass only lists what it changes + cls._box_resolved_defaults = {**getattr(cls, "_box_resolved_defaults", {}), **own} + + def __new__(cls, *args: Any, **kwargs: Any): """ Due to the way pickling works in python 3, we need to make sure the box config is created as early as possible. """ + config = _build_box_config(cls, kwargs) obj = super().__new__(cls, *args, **kwargs) - obj._box_config = _get_box_config() - obj._box_config.update( - { - "default_box": default_box, - "default_box_attr": cls.__class__ if default_box_attr is NO_DEFAULT else default_box_attr, - "default_box_none_transform": default_box_none_transform, - "default_box_create_on_get": default_box_create_on_get, - "conversion_box": conversion_box, - "box_safe_prefix": box_safe_prefix, - "frozen_box": frozen_box, - "camel_killer_box": camel_killer_box, - "modify_tuples_box": modify_tuples_box, - "box_duplicates": box_duplicates, - "box_intact_types": tuple(box_intact_types), - "box_recast": box_recast, - "box_dots": box_dots, - "box_dots_exclude": re.compile(box_dots_exclude) if box_dots_exclude else None, - "box_class": box_class if box_class is not None else cls, - "box_namespace": box_namespace, - } - ) + obj._box_config = config # Pickle reconstructs via __new__ + item assignment + __setstate__. # Item assignment happens first, while this Box still has default options, # so nested Box/BoxList values must be stored as-is (see __convert_and_store). obj._box_config["__unpickling"] = True return obj - def __init__( - self, - *args: Any, - default_box: bool = False, - default_box_attr: Any = NO_DEFAULT, - default_box_none_transform: bool = True, - default_box_create_on_get: bool = True, - frozen_box: bool = False, - camel_killer_box: bool = False, - conversion_box: bool = True, - modify_tuples_box: bool = False, - box_safe_prefix: str = "x", - box_duplicates: str = "ignore", - box_intact_types: tuple | list = (), - box_recast: dict | None = None, - box_dots: bool = False, - box_dots_exclude: str | None = None, - box_class: dict | type[Box] | None = None, - box_namespace: tuple[str, ...] | Literal[False] = (), - **kwargs: Any, - ): + def __init__(self, *args: Any, **kwargs: Any): super().__init__() - self._box_config = _get_box_config() - self._box_config.update( - { - "default_box": default_box, - "default_box_attr": self.__class__ if default_box_attr is NO_DEFAULT else default_box_attr, - "default_box_none_transform": default_box_none_transform, - "default_box_create_on_get": default_box_create_on_get, - "conversion_box": conversion_box, - "box_safe_prefix": box_safe_prefix, - "frozen_box": frozen_box, - "camel_killer_box": camel_killer_box, - "modify_tuples_box": modify_tuples_box, - "box_duplicates": box_duplicates, - "box_intact_types": tuple(box_intact_types), - "box_recast": box_recast, - "box_dots": box_dots, - "box_dots_exclude": re.compile(box_dots_exclude) if box_dots_exclude else None, - "box_class": box_class if box_class is not None else self.__class__, - "box_namespace": box_namespace, - } - ) + self._box_config = _build_box_config(self.__class__, kwargs) if not self._box_config["conversion_box"] and self._box_config["box_duplicates"] != "ignore": raise BoxError("box_duplicates are only for conversion_boxes") + if ( + self._box_config["camel_killer_box_keep_keys"] + and self._box_config["camel_killer_box"] + and not self._box_config["conversion_box"] + ): + raise BoxError("camel_killer_box_keep_keys needs conversion_box, it provides the snake_case aliases") if len(args) == 1: if isinstance(args[0], str): raise BoxValueError("Cannot extrapolate Box from string") @@ -427,8 +415,9 @@ def __dir__(self) -> list[str]: if key.isidentifier() and not iskeyword(key): items.add(key) + keep_keys = self._box_config["camel_killer_box_keep_keys"] and self._box_config["camel_killer_box"] for key in self.keys(): - if key not in items: + if key not in items or keep_keys: if self._box_config["conversion_box"]: key = self._safe_attr(key) if key: @@ -449,9 +438,12 @@ def __contains__(self, item): except BoxError: return False else: + first_item = self.__dots_int_key(first_item) if not super().__contains__(first_item): return False it = self[first_item] + if isinstance(it, Box): + children = it.__dots_int_key(children) return isinstance(it, Iterable) and children in it def keys(self, dotted: bool = False): @@ -535,6 +527,28 @@ def __setstate__(self, state): self._box_config["__created"] = True self._box_config["__unpickling"] = False + def __dots_int_key(self, item): + """ + A segment of a box_dots path made of digits also matches the int key with that value, so + "a.2" reaches {"a": {2: ...}} (#123). Only used for path segments, a str key of the same + value wins, and plain (non dotted) keys are never mapped. + """ + if ( + self._box_config["box_dots"] + and isinstance(item, str) + and item.isascii() + and item.lstrip("-").isdigit() + and not dict.__contains__(self, item) + ): + as_int = int(item) + if dict.__contains__(self, as_int): + return as_int + return item + + def __camel_destructive(self): + """camel_killer_box renames keys to snake_case unless camel_killer_box_keep_keys is set""" + return self._box_config["camel_killer_box"] and not self._box_config["camel_killer_box_keep_keys"] + def __process_dotted_key(self, item): if self._box_config["box_dots"] and isinstance(item, str): return ("[" in item) or ( @@ -689,15 +703,18 @@ def __getitem__(self, item, _ignore_default=False): if self._box_config["default_box"] and not _ignore_default: return self.__get_default(item) raise BoxKeyError(str(item)) from _exception_cause(err) - if first_item not in self.keys() and self._box_config["camel_killer_box"]: + first_item = self.__dots_int_key(first_item) + if first_item not in self.keys() and self.__camel_destructive(): first_item = _camel_killer(first_item) if first_item in self.keys(): child = self[first_item] + if isinstance(child, Box): + children = child.__dots_int_key(children) if hasattr(child, "__getitem__"): if _ignore_default and isinstance(child, (Box, box.BoxList)): return child.__getitem__(children, _ignore_default=True) return child[children] - if self._box_config["camel_killer_box"] and isinstance(item, str): + if self.__camel_destructive() and isinstance(item, str): converted = _camel_killer(item) if converted in self.keys(): return super().__getitem__(converted) @@ -770,9 +787,13 @@ def __setitem__(self, key, value): raise BoxError("Box is frozen") if self.__process_dotted_key(key): first_item, children = _parse_box_dots(self, key, setting=True) + first_item = self.__dots_int_key(first_item) if first_item in self.keys(): - if hasattr(self[first_item], "__setitem__"): - return self[first_item].__setitem__(children, value) + child = self[first_item] + if isinstance(child, Box): + children = child.__dots_int_key(children) + if hasattr(child, "__setitem__"): + return child.__setitem__(children, value) elif self._box_config["default_box"]: self._flush_pending_parent() if children[0] == "[": @@ -785,8 +806,8 @@ def __setitem__(self, key, value): else: raise BoxKeyError(f"'{self.__class__}' object has no attribute {first_item}") value = self.__recast(key, value) - if key not in self.keys() and self._box_config["camel_killer_box"]: - if self._box_config["camel_killer_box"] and isinstance(key, str): + if key not in self.keys() and self.__camel_destructive(): + if isinstance(key, str): key = _camel_killer(key) if self._box_config["conversion_box"] and self._box_config["box_duplicates"] != "ignore": self._conversion_checks(key) @@ -820,10 +841,14 @@ def __delitem__(self, key): first_item, children = _parse_box_dots(self, key) except BoxError: raise BoxKeyError(str(key)) from None - if hasattr(self[first_item], "__delitem__"): - return self[first_item].__delitem__(children) - if key not in self.keys() and self._box_config["camel_killer_box"]: - if self._box_config["camel_killer_box"] and isinstance(key, str): + first_item = self.__dots_int_key(first_item) + child = self[first_item] + if isinstance(child, Box): + children = child.__dots_int_key(children) + if hasattr(child, "__delitem__"): + return child.__delitem__(children) + if key not in self.keys() and self.__camel_destructive(): + if isinstance(key, str): for each_key in self: if _camel_killer(key) == each_key: key = each_key @@ -862,6 +887,10 @@ def __delattr__(self, item): if safe_key in self._box_config["__safe_keys"]: self.__delitem__(self._box_config["__safe_keys"][safe_key]) return + if self._box_config["default_box"] and not self._box_config["default_box_create_on_get"]: + # Every attribute of a default_box looks present (hasattr is True) without being + # stored, so deleting a missing one is a no-op. argparse.parse_args relies on this. + return raise BoxKeyError(str(err)) from _exception_cause(err) def pop(self, key, *args): @@ -883,7 +912,9 @@ def pop(self, key, *args): except KeyError: raise BoxKeyError(f"{key}") from None else: - del self[key] + if key in self: + del self[key] + # else: a default_box returned a default without storing it, there is nothing to remove return item def clear(self): @@ -1069,6 +1100,10 @@ def setdefault(self, item, default=None): def _safe_attr(self, attr): """Convert a key into something that is accessible as an attribute""" + if self._box_config["camel_killer_box_keep_keys"] and self._box_config["camel_killer_box"]: + # Keys keep their spelling, the attribute alias is the snake_case form + if isinstance(attr, str): + attr = _camel_killer(attr) if isinstance(attr, str): # By assuming most people are using string first we get substantial speed ups if attr.isidentifier() and not iskeyword(attr): @@ -1198,6 +1233,7 @@ def to_yaml( :param encoding: File encoding :param errors: How to handle encoding errors :param width: Line width for YAML output + :param sort_keys: True sorts keys alphabetically, the default False keeps insertion order :param yaml_kwargs: additional arguments to pass to yaml.dump :return: string of YAML (if no filename provided) """ diff --git a/box/box.pyi b/box/box.pyi index a1dbfdd..f5ec6da 100644 --- a/box/box.pyi +++ b/box/box.pyi @@ -6,6 +6,7 @@ from _typeshed import Incomplete class Box(dict): _box_internal_attrs: tuple[str, ...] + _box_defaults: dict[str, Any] def __new__( cls, *args: Any, @@ -15,6 +16,7 @@ class Box(dict): default_box_create_on_get: bool = ..., frozen_box: bool = ..., camel_killer_box: bool = ..., + camel_killer_box_keep_keys: bool = ..., conversion_box: bool = ..., modify_tuples_box: bool = ..., box_safe_prefix: str = ..., @@ -36,6 +38,7 @@ class Box(dict): default_box_create_on_get: bool = ..., frozen_box: bool = ..., camel_killer_box: bool = ..., + camel_killer_box_keep_keys: bool = ..., conversion_box: bool = ..., modify_tuples_box: bool = ..., box_safe_prefix: str = ..., diff --git a/box/box_list.py b/box/box_list.py index 0526fd2..0d82cb9 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -318,6 +318,7 @@ def to_yaml( :param encoding: File encoding :param errors: How to handle encoding errors :param width: Line width for YAML output + :param sort_keys: True sorts keys alphabetically, the default False keeps insertion order :param yaml_kwargs: additional arguments to pass to yaml.dump :return: string of YAML or return of `yaml.dump` """ diff --git a/box/converters.py b/box/converters.py index f14e118..e93d256 100644 --- a/box/converters.py +++ b/box/converters.py @@ -124,6 +124,7 @@ class BoxTomlDecodeError(BoxError, tomli.TOMLDecodeError): # type: ignore "default_box_create_on_get", "frozen_box", "camel_killer_box", + "camel_killer_box_keep_keys", "conversion_box", "modify_tuples_box", "box_safe_prefix", @@ -206,39 +207,44 @@ def _to_yaml( ruamel_typ: str = "rt", ruamel_attrs: dict | None = None, width: int = 120, + sort_keys: bool = False, **yaml_kwargs, ): + """ + Keys are written in insertion order. ``sort_keys=True`` sorts them alphabetically instead + (PyYAML and the ruamel ``safe`` / ``unsafe`` dumpers, the default ruamel ``rt`` dumper never sorts). + """ + if not ruamel_available and not pyyaml_available: + raise BoxError(MISSING_PARSER_ERROR) + + def ruamel_dump(stream): + yaml_dumper = YAML(typ=ruamel_typ) + yaml_dumper.default_flow_style = default_flow_style + yaml_dumper.width = width + if hasattr(yaml_dumper.representer, "sort_base_mapping_type_on_output"): + yaml_dumper.representer.sort_base_mapping_type_on_output = sort_keys + for attr, value in ruamel_attrs.items(): + setattr(yaml_dumper, attr, value) + return yaml_dumper.dump(obj, stream=stream, **yaml_kwargs) + + def pyyaml_dump(stream=None): + return yaml.dump( + obj, stream=stream, default_flow_style=default_flow_style, width=width, sort_keys=sort_keys, **yaml_kwargs + ) + if not ruamel_attrs: ruamel_attrs = {} if filename: _exists(filename, create=True) with open(filename, "w", encoding=encoding, errors=errors) as f: if ruamel_available: - yaml_dumper = YAML(typ=ruamel_typ) - yaml_dumper.default_flow_style = default_flow_style - yaml_dumper.width = width - for attr, value in ruamel_attrs.items(): - setattr(yaml_dumper, attr, value) - return yaml_dumper.dump(obj, stream=f, **yaml_kwargs) - elif pyyaml_available: - return yaml.dump(obj, stream=f, default_flow_style=default_flow_style, width=width, **yaml_kwargs) - else: - raise BoxError(MISSING_PARSER_ERROR) - - else: - if ruamel_available: - yaml_dumper = YAML(typ=ruamel_typ) - yaml_dumper.default_flow_style = default_flow_style - yaml_dumper.width = width - for attr, value in ruamel_attrs.items(): - setattr(yaml_dumper, attr, value) - with StringIO() as string_stream: - yaml_dumper.dump(obj, stream=string_stream, **yaml_kwargs) - return string_stream.getvalue() - elif pyyaml_available: - return yaml.dump(obj, default_flow_style=default_flow_style, width=width, **yaml_kwargs) - else: - raise BoxError(MISSING_PARSER_ERROR) + return ruamel_dump(f) + return pyyaml_dump(f) + if ruamel_available: + with StringIO() as string_stream: + ruamel_dump(string_stream) + return string_stream.getvalue() + return pyyaml_dump() def _ruamel_to_builtin(obj): diff --git a/box/converters.pyi b/box/converters.pyi index 975b902..4c0c70b 100644 --- a/box/converters.pyi +++ b/box/converters.pyi @@ -29,6 +29,7 @@ def _to_yaml( ruamel_typ: str = ..., ruamel_attrs: dict | None = ..., width: int = ..., + sort_keys: bool = ..., **yaml_kwargs, ): ... def _from_yaml( diff --git a/box/shorthand_box.py b/box/shorthand_box.py index 1ab7e56..82d65b9 100644 --- a/box/shorthand_box.py +++ b/box/shorthand_box.py @@ -48,16 +48,9 @@ def __repr__(self): class DDBox(SBox): - def __init__(self, *args, **kwargs): - kwargs["box_dots"] = True - kwargs["default_box"] = True - super().__init__(*args, **kwargs) - - def __new__(cls, *args, **kwargs): - obj = super().__new__(cls, *args, **kwargs) - obj._box_config["box_dots"] = True - obj._box_config["default_box"] = True - return obj + """SBox with box_dots and default_box turned on by default""" + + _box_defaults = {"box_dots": True, "default_box": True} def __repr__(self) -> str: return f"{self.__class__.__name__}({self})" diff --git a/test/test_box.py b/test/test_box.py index d06ae31..143f4b0 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -629,13 +629,13 @@ def test_default_box(self): bx4 = Box(default_box=True, default_box_attr=None) assert bx4.who_is_there is None - bx5 = Box(default_box=True, default_box_attr=[]) + bx5 = Box(default_box=True, default_box_attr=[], default_box_create_on_get=True) assert isinstance(bx5.empty_list_please, list) assert len(bx5.empty_list_please) == 0 bx5.empty_list_please.append(1) assert bx5.empty_list_please[0] == 1 - bx6 = Box(default_box=True, default_box_attr=[]) + bx6 = Box(default_box=True, default_box_attr=[], default_box_create_on_get=True) my_list = bx6.get("new_list") my_list.append(5) assert bx6.get("new_list")[0] == 5 @@ -1536,7 +1536,7 @@ def test_box_safe_references(self): assert id(a) != id(b.a) def test_default_box_restricted_calls(self): - a = Box(default_box=True) + a = Box(default_box=True, default_box_create_on_get=True) with pytest.raises(BoxKeyError): a._test_thing_ assert len(list(a.keys())) == 0 @@ -1552,11 +1552,11 @@ def test_default_box_restricted_calls(self): assert len(list(a.keys())) == 2 def test_default_dots(self): - bx1 = Box(default_box=True, box_dots=True) + bx1 = Box(default_box=True, box_dots=True, default_box_create_on_get=True) bx1["a.a.a"] assert bx1 == {"a": {"a": {"a": {}}}} - a = Box(default_box=True, box_dots=True) + a = Box(default_box=True, box_dots=True, default_box_create_on_get=True) a["a."] a["a.."] assert a == {"a": {"": {"": {}}}} @@ -1695,7 +1695,7 @@ def test_box_greek(self): assert a == Box({"σeq": 1, "μeq": 2}) def test_box_default_not_create_on_get(self): - box = Box(default_box=True) + box = Box(default_box=True, default_box_create_on_get=True) assert box.a.b.c == Box() @@ -2194,8 +2194,7 @@ def test_deep_assignment_and_item_forms(self): def test_failed_operations_do_not_create(self): b = _no_create_box() - with pytest.raises(BoxKeyError): - del b.x.nothing + del b.x.nothing # a missing attribute of a default_box looks present, deleting it is a no-op with pytest.raises(BoxKeyError): b.x.items = 1 # protected key b.x.update({}) @@ -2306,12 +2305,54 @@ class Sub(Box): b.x.y = 1 assert type(b.x) is Sub - def test_create_on_get_default_unchanged(self): - b = Box(default_box=True) + def test_create_on_get_true_stores_on_lookup(self): + b = Box(default_box=True, default_box_create_on_get=True) b.a.b assert b.to_dict() == {"a": {"b": {}}} assert "__pending_parent" not in b.a._box_config + def test_create_on_get_is_off_by_default(self): + b = Box(default_box=True) + assert b._box_config["default_box_create_on_get"] is False + assert b.a.b == Box() + assert b.to_dict() == {} + b.a.b = 1 + assert b.to_dict() == {"a": {"b": 1}} + + def test_ipython_style_probing_does_not_add_keys(self): + # IPython / Spyder look up attributes such as size and compute on objects (#262) + b = Box(default_box=True) + for name in ("size", "compute", "shape", "_repr_html_"): + hasattr(b, name) + assert b.to_dict() == {} + + def test_in_place_change_of_default_value_is_not_kept(self): + # Documented trade off of the default: store the value first, or use default_box_create_on_get=True + b = Box(default_box=True, default_box_attr=[]) + b.tags.append(1) + assert b.to_dict() == {} + b.tags = b.tags + [1] + assert b.to_dict() == {"tags": [1]} + + def test_pop_and_delattr_of_missing_key(self): + b = Box(default_box=True) + assert b.pop("missing") == Box() + assert hasattr(b, "_unrecognized_args") # what argparse.parse_args does with a namespace + delattr(b, "_unrecognized_args") + assert b.to_dict() == {} + with pytest.raises(KeyError): + Box().pop("missing") + with pytest.raises(AttributeError): + delattr(Box(), "missing") + + def test_argparse_namespace(self): + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--name", default="x") + args = parser.parse_args(["--name", "y"], namespace=Box(default_box=True)) + assert args.to_dict() == {"name": "y"} + def test_no_default_box_unchanged(self): with pytest.raises(BoxKeyError): Box().x.y = 1 diff --git a/test/test_box_defaults.py b/test/test_box_defaults.py new file mode 100644 index 0000000..bb2b788 --- /dev/null +++ b/test/test_box_defaults.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Subclasses can change Box option defaults with _box_defaults (#296, #223, #210).""" + +import copy +import pickle + +import pytest + +from box import Box, BoxError, BoxList, ConfigBox, DDBox + + +class DefaultBox(Box): + _box_defaults = {"default_box": True} + + +class FrozenDefaultBox(DefaultBox): + _box_defaults = {"frozen_box": True} + + +class TestBoxDefaults: + def test_defaults_apply(self): + b = DefaultBox() + assert b.missing == DefaultBox() + assert b._box_config["default_box"] is True + assert Box()._box_config["default_box"] is False + + def test_explicit_option_wins(self): + b = DefaultBox(default_box=False) + with pytest.raises(AttributeError): + b.missing + + def test_nested_boxes_keep_class_and_options(self): + b = DefaultBox({"a": {"b": {"c": 1}}, "l": [{"x": 1}]}) + assert type(b.a) is DefaultBox and type(b.a.b) is DefaultBox + assert type(b.l[0]) is DefaultBox + assert b.a.b.missing == DefaultBox() + b.new.deep = 1 + assert type(b.new) is DefaultBox + assert b.to_dict() == {"a": {"b": {"c": 1}}, "l": [{"x": 1}], "new": {"deep": 1}} + + def test_explicit_option_carries_to_nested_boxes(self): + b = DefaultBox({"a": {"b": 1}}, default_box=False) + with pytest.raises(AttributeError): + b.a.missing + + def test_inherited_and_extended(self): + b = FrozenDefaultBox({"a": 1}) + assert b._box_config["default_box"] is True + assert b._box_config["frozen_box"] is True + with pytest.raises(BoxError): + b.a = 2 + assert DefaultBox._box_resolved_defaults == {"default_box": True} + + def test_unknown_option_is_rejected_at_class_creation(self): + with pytest.raises(BoxError, match="defualt_box"): + + class Typo(Box): + _box_defaults = {"defualt_box": True} + + def test_no_init_override_needed(self): + # The pattern people tried in #296 / #223 fails, this is the replacement + class MyConfig(Box): + _box_defaults = {"default_box": True, "box_dots": True} + + config = MyConfig() + config["server.host"] = "localhost" + assert config.to_dict() == {"server": {"host": "localhost"}} + + def test_copy_pickle_and_conversions_keep_defaults(self): + b = DefaultBox({"a": {"b": 1}}) + for other in (b.copy(), copy.deepcopy(b), pickle.loads(pickle.dumps(b)), DefaultBox.from_json(b.to_json())): + assert type(other) is DefaultBox + assert other.a.missing == DefaultBox() + + def test_box_list_conversion(self): + bl = BoxList([{"a": 1}], box_class=DefaultBox) + assert type(bl[0]) is DefaultBox + assert bl[0].missing == DefaultBox() + + def test_ddbox_uses_defaults_and_can_be_overridden(self): + dd = DDBox({"a": {"b": 1}}) + assert dd["a.b"] == 1 + assert dd.x == DDBox() + assert DDBox(default_box=False)._box_config["default_box"] is False + + def test_other_subclasses_unchanged(self): + assert ConfigBox()._box_config["default_box"] is False + assert ConfigBox._box_resolved_defaults == {} + + def test_options_are_not_data(self): + b = DefaultBox(a=1, box_dots=True) + assert b.to_dict() == {"a": 1} + assert b._box_config["box_dots"] is True diff --git a/test/test_box_keys_8.py b/test/test_box_keys_8.py new file mode 100644 index 0000000..690dc42 --- /dev/null +++ b/test/test_box_keys_8.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Integer keys in box_dots paths (#123) and non-destructive camel killer (#279).""" + +import pytest + +from box import Box, BoxError, BoxKeyError, ConfigBox + + +class TestDotsIntegerKeys: + def test_lookup(self): + info = Box({"uno": {2: "tres", "cuatro": 5}}, default_box=True, box_dots=True) + assert info["uno.2"] == "tres" + assert info["uno.cuatro"] == 5 + assert "uno.2" in info + assert "uno.3" not in info + + def test_first_segment_and_negative(self): + b = Box({1: {"a": "x"}, "n": {-1: "neg"}}, box_dots=True) + assert b["1.a"] == "x" + assert b["n.-1"] == "neg" + assert "1.a" in b + + def test_plain_keys_are_not_mapped(self): + b = Box({2: "int"}, box_dots=True) + with pytest.raises(BoxKeyError): + b["2"] + assert "2" not in b + b["2"] = "str" + assert b.to_dict() == {2: "int", "2": "str"} + + def test_string_key_still_wins(self): + b = Box({"uno": {2: "int", "2": "str"}}, box_dots=True) + assert b["uno.2"] == "str" + assert b.uno[2] == "int" + + def test_set_and_delete_update_the_int_key(self): + b = Box({"uno": {2: "tres"}}, box_dots=True) + b["uno.2"] = "dos" + assert b.to_dict() == {"uno": {2: "dos"}} + del b["uno.2"] + assert b.to_dict() == {"uno": {}} + + def test_missing_still_missing(self): + b = Box({"uno": {2: "tres"}}, box_dots=True) + with pytest.raises(BoxKeyError): + b["uno.3"] + b2 = Box({"uno": {}}, box_dots=True, default_box=True) + assert b2["uno.3"] == Box() + + def test_not_digits_or_without_box_dots(self): + b = Box({"uno": {2: "tres", 1.5: "float"}}, box_dots=True) + with pytest.raises(BoxKeyError): + b["uno.²"] # a unicode digit, not an int + with pytest.raises(BoxKeyError): + Box({2: "tres"})["2"] + + def test_box_list_index_unchanged(self): + b = Box({"items": [{"a": 1}, {"a": 2}]}, box_dots=True) + assert b["items[1].a"] == 2 + + +class TestCamelKillerKeepKeys: + def test_round_trip_keeps_original_keys(self): + data = Box({"loadBalancer": "foo", "sneaky_snake": 1}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert data.load_balancer == "foo" + assert data.loadBalancer == "foo" + data.load_balancer = "bar" + assert data.to_dict() == {"loadBalancer": "bar", "sneaky_snake": 1} + + def test_nested_and_lists(self): + data = Box( + {"spec": {"clusterIP": "1", "ports": [{"targetPort": 80}]}}, + camel_killer_box=True, + camel_killer_box_keep_keys=True, + ) + assert data.spec.cluster_ip == "1" + assert data.spec.ports[0].target_port == 80 + data.spec.ports[0].target_port = 8080 + assert data.to_dict() == {"spec": {"clusterIP": "1", "ports": [{"targetPort": 8080}]}} + + def test_item_access_uses_original_keys(self): + data = Box({"loadBalancer": "foo"}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert data["loadBalancer"] == "foo" + with pytest.raises(BoxKeyError): + data["load_balancer"] + + def test_new_keys_and_delete(self): + data = Box({"loadBalancer": "foo"}, camel_killer_box=True, camel_killer_box_keep_keys=True) + data.newField = 1 + data.other_field = 2 + assert data.new_field == 1 + del data.load_balancer + assert data.to_dict() == {"newField": 1, "other_field": 2} + + def test_dir_lists_snake_aliases(self): + data = Box({"loadBalancer": "foo"}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert "load_balancer" in dir(data) + + def test_destructive_default_unchanged(self): + data = Box({"loadBalancer": "foo"}, camel_killer_box=True) + assert data.to_dict() == {"load_balancer": "foo"} + + def test_needs_conversion_box(self): + with pytest.raises(BoxError): + Box(camel_killer_box=True, camel_killer_box_keep_keys=True, conversion_box=False) + + def test_as_subclass_default(self): + class KubeBox(Box): + _box_defaults = {"camel_killer_box": True, "camel_killer_box_keep_keys": True} + + obj = KubeBox.from_json('{"metadata": {"resourceVersion": "1"}}') + assert obj.metadata.resource_version == "1" + assert obj.to_json() == '{"metadata": {"resourceVersion": "1"}}' + + def test_config_box(self): + cb = ConfigBox({"maxConnections": "5"}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert cb.int("max_connections") == 5 + assert cb.to_dict() == {"maxConnections": "5"} diff --git a/test/test_yaml_order.py b/test/test_yaml_order.py new file mode 100644 index 0000000..fd9148f --- /dev/null +++ b/test/test_yaml_order.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""to_yaml writes keys in insertion order with every YAML backend (#104).""" + +import pytest + +import box.converters as converters +from box import Box, BoxList + +DATA = {"zlast": 1, "afirst": {"z": 1, "a": 2}} +IN_ORDER = "zlast: 1\nafirst:\n z: 1\n a: 2\n" +SORTED = "afirst:\n a: 2\n z: 1\nzlast: 1\n" + + +@pytest.fixture(params=["ruamel-rt", "ruamel-safe", "pyyaml"]) +def backend(request, monkeypatch): + if request.param == "pyyaml": + if not converters.pyyaml_available: + pytest.skip("PyYAML is not installed") + monkeypatch.setattr(converters, "ruamel_available", False) + return {} + if not converters.ruamel_available: + pytest.skip("ruamel.yaml is not installed") + return {"ruamel_typ": request.param.split("-")[1]} + + +class TestYamlOrder: + def test_insertion_order_by_default(self, backend): + assert Box(DATA).to_yaml(**backend) == IN_ORDER + + def test_sort_keys_opt_in(self, backend): + if backend.get("ruamel_typ", "safe") == "rt": + pytest.skip("the ruamel round trip dumper never sorts") + assert Box(DATA).to_yaml(sort_keys=True, **backend) == SORTED + + def test_file_output_and_box_list(self, backend, tmp_path): + path = tmp_path / "order.yaml" + Box(DATA).to_yaml(filename=path, **backend) + assert path.read_text() == IN_ORDER + assert BoxList([DATA]).to_yaml(**backend) == "- zlast: 1\n afirst:\n z: 1\n a: 2\n" + + def test_round_trip_keeps_order(self, backend): + assert list(Box.from_yaml(Box(DATA).to_yaml(**backend)).keys()) == ["zlast", "afirst"] From 78046df4d035604cbe8a534263422de61c1ba16f Mon Sep 17 00:00:00 2001 From: lin Date: Wed, 4 Nov 2026 13:06:02 +0800 Subject: [PATCH 54/61] Convert nested containers during BoxList in-place addition --- AUTHORS.rst | 1 + CHANGES.rst | 1 + box/box_list.py | 3 ++- test/test_box_list.py | 62 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 66 insertions(+), 1 deletion(-) diff --git a/AUTHORS.rst b/AUTHORS.rst index 3bee032..bba27fc 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -5,6 +5,7 @@ reporting, all input is greatly appreciated! Code contributions: +- lin (theman6660) - Alexandre Decan (AlexandreDecan) - dhilipsiva (dhilipsiva) - MAA (FooBarQuaxx) diff --git a/CHANGES.rst b/CHANGES.rst index 759bcc2..f606aac 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -42,6 +42,7 @@ Changes * Fixing BoxList.__deepcopy__ not preserving box options (thanks to chuenchen309) * Fixing second dotted write into an existing BoxList element discarding data (thanks to binggao1230) * Fixing dicts and lists assigned to BoxList items and slices not being converted (thanks to x0Lazarus) +* Fixing dicts and lists added with BoxList ``+=`` not being converted (thanks to lin) * Fixing BoxList.extend(self) revisiting its own appended values (thanks to x0Lazarus) * Fixing BoxList construction testing the truth value of the iterable (thanks to fhgffy) * Fixing BoxList to_json / from_json multiline not working with strings (thanks to shguild) diff --git a/box/box_list.py b/box/box_list.py index 0d82cb9..8a3f67c 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -140,7 +140,8 @@ def converted_items(): def __iadd__(self, value): if self.box_options.get("frozen_box"): raise BoxError("BoxList is frozen") - return super().__iadd__(value) + self.extend(value) + return self def __imul__(self, value): if self.box_options.get("frozen_box"): diff --git a/test/test_box_list.py b/test/test_box_list.py index c92cfd2..469c3e9 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -604,3 +604,65 @@ def test_frozen_list_inplace_mutations(mutate, expected): mutate(mutable) assert mutable is alias assert mutable == expected + + +@pytest.mark.parametrize("as_iterator", [False, True]) +def test_iadd_converts_containers_and_preserves_options(as_iterator): + class CustomBox(Box): + pass + + values = [{"someKey": 1}, [{"otherKey": 2}]] + source = iter(values) if as_iterator else values + data = BoxList([0], box_class=CustomBox, camel_killer_box=True) + original = data + + data += source + + assert data is original + assert data[0] == 0 + assert isinstance(data[1], CustomBox) + assert data[1].some_key == 1 + assert isinstance(data[2], BoxList) + assert isinstance(data[2][0], CustomBox) + assert data[2][0].other_key == 2 + assert data.box_options["box_class"] is CustomBox + assert data[2].box_options["camel_killer_box"] is True + assert values == [{"someKey": 1}, [{"otherKey": 2}]] + + +def test_iadd_respects_intact_types(): + item = {"value": 1} + data = BoxList(box_intact_types=(dict,)) + data += [item] + assert data[0] is item + + +@pytest.mark.parametrize("values", [[], [1, 2], [{"value": 1}]]) +def test_iadd_self(values): + data = BoxList(values) + original = data + data += data + assert data is original + assert data.to_list() == values + values + + +def test_iadd_partial_iterator_failure(): + def source(): + yield {"value": 1} + raise RuntimeError("source failed") + + data = BoxList() + with pytest.raises(RuntimeError, match="source failed"): + data += source() + assert len(data) == 1 + assert isinstance(data[0], Box) + assert data[0].value == 1 + + +def test_iadd_frozen_does_not_consume_source(): + source = iter([{"value": 1}]) + data = BoxList([0], frozen_box=True) + with pytest.raises(BoxError, match="BoxList is frozen"): + data += source + assert next(source) == {"value": 1} + assert data == [0] From 5a7ada1078d1af02e461789406f948ee8cfc5e51 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Wed, 4 Nov 2026 08:14:25 -0500 Subject: [PATCH 55/61] Publish to PyPI with Trusted Publishing and pin actions to SHAs (#348) - All build jobs (generic sdist/wheel, macOS/Windows Cython wheels, manylinux cibuildwheel) run without secrets and upload artifacts - A single publish job, gated on every build succeeding, downloads all distributions and uploads via PyPI Trusted Publishing (OIDC) in the "pypi" environment; its only permission is id-token: write - No PYPI_USERNAME / PYPI_PASSWORD secrets are used anymore - Pin every action in both workflows to a full commit SHA - Default token permissions to none, checkout without persisted credentials, add job timeouts, twine check every build Co-authored-by: Claude Opus 5.5 --- .github/workflows/pythonpublish.yml | 108 +++++++++++++++++----------- .github/workflows/tests.yml | 16 ++--- 2 files changed, 76 insertions(+), 48 deletions(-) diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index ce902de..f3a52ba 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -1,5 +1,8 @@ -# This workflow will upload a Python Package using Twine when a release is created -# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries +# Builds and publishes to PyPI when a GitHub release is created. +# Every build job runs without secrets. A single publish job, whose only permission is +# id-token: write, uploads all distributions via PyPI Trusted Publishing (OIDC), so no PyPI +# password or token is stored in GitHub: https://docs.pypi.org/trusted-publishers/ +# All actions are pinned to full commit SHAs; the comment shows the matching release tag. name: Upload Python Package @@ -7,16 +10,22 @@ on: release: types: [ created ] -jobs: - deploy-generic: +permissions: {} +jobs: + build-generic: runs-on: ubuntu-latest + timeout-minutes: 20 + permissions: + contents: read steps: - - uses: actions/checkout@v7 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false - name: Set up Python - uses: actions/setup-python@v7 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: '3.15' @@ -24,27 +33,36 @@ jobs: uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 # Isolated build: Cython is not part of the build requirements, so this is the pure Python sdist and wheel - - name: Build and Publish - env: - TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} - TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} - + - name: Build and check run: | uv build - uvx twine==6.2.0 upload dist/* + uvx twine==6.2.0 check dist/* - deploy-cython: + - name: Upload distribution artifact + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: dist-generic + path: dist/* + if-no-files-found: error + + build-cython: strategy: + fail-fast: false matrix: os: [macos-latest, windows-latest] python-version: ["3.11", "3.12", "3.13", "3.14", "3.15"] runs-on: ${{ matrix.os }} + timeout-minutes: 30 + permissions: + contents: read steps: - - uses: actions/checkout@v7 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false - name: Set up Python ${{ matrix.python-version }} id: setup-python - uses: actions/setup-python@v7 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ matrix.python-version }} - name: Install uv @@ -53,21 +71,28 @@ jobs: run: | uv venv --python "${{ steps.setup-python.outputs.python-path }}" uv pip install "setuptools>=77" wheel "Cython>=3.3.0" - - name: Build and publish - env: - TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} - TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} - # No build isolation so the Cython installed above is used to build the compiled wheel + # No build isolation so the Cython installed above is used to build the compiled wheel + - name: Build and check run: | uv build --wheel --no-build-isolation - uvx twine==6.2.0 upload dist/* + uvx twine==6.2.0 check dist/* + - name: Upload wheel artifact + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: dist-cython-${{ matrix.os }}-${{ matrix.python-version }} + path: dist/*.whl + if-no-files-found: error - # Building runs the test suite (third party test dependencies), so it happens in a job without - # access to the PyPI credentials. A separate job only downloads the built wheels and uploads them. build-cython-manylinux: runs-on: ubuntu-latest + timeout-minutes: 60 + permissions: + contents: read + steps: - - uses: actions/checkout@v7 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false - name: Install uv uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 @@ -76,27 +101,30 @@ jobs: run: uvx cibuildwheel==4.3.5 --output-dir dist - name: Upload wheel artifact - uses: actions/upload-artifact@v7 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: - name: python_box_manylinux + name: dist-cython-manylinux path: dist/*-manylinux*.whl + if-no-files-found: error - deploy-cython-manylinux: - needs: build-cython-manylinux + # Publishes only after every build succeeds, so a release is never left half uploaded + publish: + needs: [ build-generic, build-cython, build-cython-manylinux ] runs-on: ubuntu-latest + timeout-minutes: 15 + environment: + name: pypi + url: https://pypi.org/p/python-box + permissions: + id-token: write # Required for Trusted Publishing; the only permission this job has + steps: - - name: Download wheels - uses: actions/download-artifact@v7 + - name: Download all distributions + uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0 with: - name: python_box_manylinux + pattern: dist-* path: dist + merge-multiple: true - - name: Install uv - uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 - - - name: Publish - env: - TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} - TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} - run: | - uvx twine==6.2.0 upload dist/*-manylinux*.whl + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3 diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index b92442d..5a8b2b3 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -13,7 +13,7 @@ jobs: lint: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v7 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Install uv uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: @@ -30,10 +30,10 @@ jobs: os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v7 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Set up Python ${{ matrix.python-version }} id: setup-python - uses: actions/setup-python@v7 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ matrix.python-version }} - name: Install uv @@ -64,7 +64,7 @@ jobs: Remove-item box -recurse -force uv run --no-sync pytest -vv - name: Upload wheel artifact - uses: actions/upload-artifact@v7 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: python_box_${{matrix.os}}_${{ matrix.python-version }} path: dist/*.whl @@ -72,7 +72,7 @@ jobs: package-manylinux-checks: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v7 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Install uv uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: @@ -82,7 +82,7 @@ jobs: run: uvx cibuildwheel==4.3.5 --output-dir dist - name: Upload wheel artifact - uses: actions/upload-artifact@v7 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: python_box_manylinux path: dist/*-manylinux*.whl @@ -94,10 +94,10 @@ jobs: os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v7 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Set up Python ${{ matrix.python-version }} id: setup-python - uses: actions/setup-python@v7 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ matrix.python-version }} - name: Install uv From 7bf48196569ee1be3e8bde3258703ca920fea8f9 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Wed, 4 Nov 2026 08:29:55 -0500 Subject: [PATCH 56/61] Reach 100% line and branch coverage, enforce it in CI Tests for the remaining reachable paths (error branches, optional YAML / TOML / TOON backends, ConfigBox index upkeep, default_box_attr call signatures, IPython probes, reflected operators). Code that could not run was removed instead: * _parse_box_dots error handlers at call sites that already guarantee a "." or "[" in the key, and its unreachable `setting` split * the _dunder_ check in __get_default (__getattr__ refuses those names first) and the __getstate__ AttributeError case (Box defines __getstate__) * tomli / toml read fallbacks (tomllib is always present on Python 3.11+) and try/except blocks around TOML writes that only caught decode errors * box_from_string's BoxList fallback for TOML (a TOML document is always a table) * DDBox.__repr__, identical to the inherited SBox one Import time environment fallbacks and the Python 3.11 slice branch are marked `pragma: no cover`. A new pure Python CI job fails below 100%. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/tests.yml | 19 ++ box/box.py | 71 +++----- box/config_box.py | 5 +- box/converters.py | 88 +++------ box/from_file.py | 3 +- box/shorthand_box.py | 3 - test/test_coverage_paths.py | 351 ++++++++++++++++++++++++++++++++++++ 7 files changed, 423 insertions(+), 117 deletions(-) create mode 100644 test/test_coverage_paths.py diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 5a8b2b3..de1e3cf 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -23,6 +23,25 @@ jobs: - name: Ruff format run: uvx ruff@0.17.3 format --check . + coverage: + # Pure Python on purpose: Cython compiled modules can't be traced by coverage + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - name: Set up Python + id: setup-python + uses: actions/setup-python@v7 + with: + python-version: "3.15" + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 + with: + enable-cache: true + - name: Install dependencies + run: uv sync --python "${{ steps.setup-python.outputs.python-path }}" --group test --no-install-project + - name: Require 100% line and branch coverage + run: uv run --no-sync pytest --cov=box --cov-branch --cov-report=term-missing --cov-fail-under=100 test/ + package-checks: strategy: matrix: diff --git a/box/box.py b/box/box.py index 3f0b80d..cd8782d 100644 --- a/box/box.py +++ b/box/box.py @@ -116,14 +116,13 @@ def _to_native_tuple(iterable): return tuple(out_list) -def _parse_box_dots(bx, item, setting=False): +def _parse_box_dots(bx, item): + """Split a box_dots key at its first "." or "[". Callers only pass keys that contain one.""" for idx, char in enumerate(item): if char == "[": return item[:idx], item[idx:] elif char == ".": return item[:idx], item[idx + 1 :] - if setting and "." in item: - return item.split(".", 1) raise BoxError("Could not split box dots properly") @@ -433,18 +432,14 @@ def __contains__(self, item): return True if "." not in item: return False - try: - first_item, children = _parse_box_dots(self, item) - except BoxError: + first_item, children = _parse_box_dots(self, item) + first_item = self.__dots_int_key(first_item) + if not super().__contains__(first_item): return False - else: - first_item = self.__dots_int_key(first_item) - if not super().__contains__(first_item): - return False - it = self[first_item] - if isinstance(it, Box): - children = it.__dots_int_key(children) - return isinstance(it, Iterable) and children in it + it = self[first_item] + if isinstance(it, Box): + children = it.__dots_int_key(children) + return isinstance(it, Iterable) and children in it def keys(self, dotted: bool = False): if not dotted: @@ -557,7 +552,7 @@ def __process_dotted_key(self, item): ) return False - def __get_default(self, item, attr=False): + def __get_default(self, item): if item in ("getdoc", "shape") and _is_ipython(): return None default_value = self._box_config["default_box_attr"] @@ -593,20 +588,18 @@ def __get_default(self, item, attr=False): else: value = default_value if self._box_config["default_box_create_on_get"]: - if not attr or not (item.startswith("_") and item.endswith("_")): - if self.__process_dotted_key(item): - first_item, children = _parse_box_dots(self, item, setting=True) - if first_item in self.keys(): - if hasattr(self[first_item], "__setitem__"): - self[first_item].__setitem__(children, value) - else: - self._flush_pending_parent() - super().__setitem__( - first_item, self._box_config["box_class"](**self.__box_config(extra_namespace=first_item)) - ) - self[first_item].__setitem__(children, value) - else: - super().__setitem__(item, value) + if self.__process_dotted_key(item): + first_item, children = _parse_box_dots(self, item) + # An existing first_item only gets here when its value can't be looked into + # (for example an int), so there is nowhere to store the default + if first_item not in self.keys(): + self._flush_pending_parent() + super().__setitem__( + first_item, self._box_config["box_class"](**self.__box_config(extra_namespace=first_item)) + ) + self[first_item].__setitem__(children, value) + else: + super().__setitem__(item, value) elif isinstance(value, Box) and not self.__process_dotted_key(item): # Lookups stay ephemeral, but a later assignment on this child # should create the missing parent keys (see _flush_pending_parent). @@ -697,12 +690,7 @@ def __getitem__(self, item, _ignore_default=False): new_box[x] = self[x] return new_box if self.__process_dotted_key(item): - try: - first_item, children = _parse_box_dots(self, item) - except BoxError: - if self._box_config["default_box"] and not _ignore_default: - return self.__get_default(item) - raise BoxKeyError(str(item)) from _exception_cause(err) + first_item, children = _parse_box_dots(self, item) first_item = self.__dots_int_key(first_item) if first_item not in self.keys() and self.__camel_destructive(): first_item = _camel_killer(first_item) @@ -722,7 +710,7 @@ def __getitem__(self, item, _ignore_default=False): return self.__get_default(item) raise BoxKeyError(str(err)) from _exception_cause(err) except TypeError as err: - if isinstance(item, slice): + if isinstance(item, slice): # pragma: no cover (Python 3.11, slices became hashable in 3.12) new_box = self._box_config["box_class"](**self.__box_config()) for x in list(super().keys())[item.start : item.stop : item.step]: new_box[x] = self[x] @@ -736,8 +724,6 @@ def __getattr__(self, item): except KeyError: value = object.__getattribute__(self, item) except AttributeError as err: - if item == "__getstate__": - raise BoxKeyError(item) from _exception_cause(err) if item == "_box_config": raise BoxError("_box_config key must exist") from _exception_cause(err) if self._box_config["conversion_box"]: @@ -747,7 +733,7 @@ def __getattr__(self, item): if self._box_config["default_box"]: if item.startswith("_") and item.endswith("_"): raise BoxKeyError(f"{item}: Does not exist and internal methods are never defaulted") - return self.__get_default(item, attr=True) + return self.__get_default(item) raise BoxKeyError(str(err)) from _exception_cause(err) return value @@ -786,7 +772,7 @@ def __setitem__(self, key, value): if key != "_box_config" and self._box_config["frozen_box"] and self._box_config["__created"]: raise BoxError("Box is frozen") if self.__process_dotted_key(key): - first_item, children = _parse_box_dots(self, key, setting=True) + first_item, children = _parse_box_dots(self, key) first_item = self.__dots_int_key(first_item) if first_item in self.keys(): child = self[first_item] @@ -837,10 +823,7 @@ def __delitem__(self, key): if self._box_config["frozen_box"]: raise BoxError("Box is frozen") if key not in self.keys() and self.__process_dotted_key(key): - try: - first_item, children = _parse_box_dots(self, key) - except BoxError: - raise BoxKeyError(str(key)) from None + first_item, children = _parse_box_dots(self, key) first_item = self.__dots_int_key(first_item) child = self[first_item] if isinstance(child, Box): diff --git a/box/config_box.py b/box/config_box.py index 705938b..fe57b73 100644 --- a/box/config_box.py +++ b/box/config_box.py @@ -78,10 +78,7 @@ def _ci_resolve(self, key): if config["box_dots_exclude"] and config["box_dots_exclude"].match(key): return key # Match the first segment of a dotted path, nested ConfigBoxes match the rest - try: - first, rest = _parse_box_dots(self, key) - except BoxError: - return key + first, rest = _parse_box_dots(self, key) found = self._ci_key(first) if found is not None and found != first: return f"{found}{rest}" if rest.startswith("[") else f"{found}.{rest}" diff --git a/box/converters.py b/box/converters.py index e93d256..93100ae 100644 --- a/box/converters.py +++ b/box/converters.py @@ -5,7 +5,7 @@ # Abstract converter functions for use in any Box class import csv import json -from collections.abc import Callable +import tomllib from io import StringIO from os import PathLike from pathlib import Path @@ -19,22 +19,20 @@ try: from ruamel.yaml import YAML, version_info -except ImportError: +except ImportError: # pragma: no cover (depends on installed packages) ruamel_available = False else: - if version_info[1] < 17: + if version_info[1] < 17: # pragma: no cover (depends on installed packages) ruamel_available = False try: import yaml -except ImportError: +except ImportError: # pragma: no cover (depends on installed packages) pyyaml_available = False MISSING_PARSER_ERROR = "No YAML Parser available, please install ruamel.yaml>=0.17 or PyYAML" -toml_read_library: Any | None = None toml_write_library: Any | None = None -toml_decode_error: Callable | None = None __all__ = [ "_to_json", @@ -52,51 +50,25 @@ ] -class BoxTomlDecodeError(BoxError): - """Toml Decode Error""" - +# Reading uses tomllib, which is always available on the supported Python versions (3.11+) +toml_read_library = tomllib +toml_decode_error = tomllib.TOMLDecodeError -try: - import toml -except ImportError: - pass -else: - toml_read_library = toml - toml_write_library = toml - toml_decode_error = toml.TomlDecodeError - - class BoxTomlDecodeError(BoxError, toml.TomlDecodeError): # type: ignore - """Toml Decode Error""" - - -try: - import tomllib -except ImportError: - pass -else: - toml_read_library = tomllib - toml_decode_error = tomllib.TOMLDecodeError - class BoxTomlDecodeError(BoxError, tomllib.TOMLDecodeError): # type: ignore - """Toml Decode Error""" - - -try: - import tomli -except ImportError: - pass -else: - toml_read_library = tomli - toml_decode_error = tomli.TOMLDecodeError - - class BoxTomlDecodeError(BoxError, tomli.TOMLDecodeError): # type: ignore - """Toml Decode Error""" +class BoxTomlDecodeError(BoxError, tomllib.TOMLDecodeError): # type: ignore + """Toml Decode Error""" +# Writing needs tomli-w, or the older toml package as a fallback try: import tomli_w -except ImportError: - pass +except ImportError: # pragma: no cover (depends on installed packages) + try: + import toml + except ImportError: + pass + else: + toml_write_library = toml else: toml_write_library = tomli_w @@ -221,7 +193,7 @@ def ruamel_dump(stream): yaml_dumper = YAML(typ=ruamel_typ) yaml_dumper.default_flow_style = default_flow_style yaml_dumper.width = width - if hasattr(yaml_dumper.representer, "sort_base_mapping_type_on_output"): + if hasattr(yaml_dumper.representer, "sort_base_mapping_type_on_output"): # pragma: no branch (older ruamel) yaml_dumper.representer.sort_base_mapping_type_on_output = sort_keys for attr, value in ruamel_attrs.items(): setattr(yaml_dumper, attr, value) @@ -320,22 +292,14 @@ def _to_toml(obj, filename: str | PathLike | None = None, encoding: str = "utf-8 if filename: _exists(filename, create=True) if toml_write_library.__name__ == "toml": # type: ignore + # The toml package writes text, tomli-w writes bytes with open(filename, "w", encoding=encoding, errors=errors) as f: - try: - toml_write_library.dump(obj, f) # type: ignore - except toml_decode_error as err: # type: ignore - raise BoxTomlDecodeError(err) from err + toml_write_library.dump(obj, f) # type: ignore else: with open(filename, "wb") as f: - try: - toml_write_library.dump(obj, f) # type: ignore - except toml_decode_error as err: # type: ignore - raise BoxTomlDecodeError(err) from err + toml_write_library.dump(obj, f) # type: ignore else: - try: - return toml_write_library.dumps(obj) # type: ignore - except toml_decode_error as err: # type: ignore - raise BoxTomlDecodeError(err) from err + return toml_write_library.dumps(obj) # type: ignore def _from_toml( @@ -346,12 +310,8 @@ def _from_toml( ): if filename: _exists(filename) - if toml_read_library.__name__ == "toml": # type: ignore - with open(filename, "r", encoding=encoding, errors=errors) as f: - data = toml_read_library.load(f) # type: ignore - else: - with open(filename, "rb") as f: - data = toml_read_library.load(f) # type: ignore + with open(filename, "rb") as f: + data = toml_read_library.load(f) elif toml_string: data = toml_read_library.loads(toml_string) # type: ignore else: diff --git a/box/from_file.py b/box/from_file.py index e3a84af..7323dbf 100644 --- a/box/from_file.py +++ b/box/from_file.py @@ -153,8 +153,7 @@ def box_from_string(content: str, string_type: str = "json") -> Box | BoxList: return Box.from_toml(toml_string=content) except toml_decode_error: # type: ignore raise BoxError("File is not TOML as expected") - except BoxError: - return BoxList.from_toml(toml_string=content) + # A TOML document is always a table, so unlike the other formats it is never a BoxList elif string_type == "yaml": try: return Box.from_yaml(yaml_string=content) diff --git a/box/shorthand_box.py b/box/shorthand_box.py index 82d65b9..a7e424f 100644 --- a/box/shorthand_box.py +++ b/box/shorthand_box.py @@ -51,6 +51,3 @@ class DDBox(SBox): """SBox with box_dots and default_box turned on by default""" _box_defaults = {"box_dots": True, "default_box": True} - - def __repr__(self) -> str: - return f"{self.__class__.__name__}({self})" diff --git a/test/test_coverage_paths.py b/test/test_coverage_paths.py new file mode 100644 index 0000000..195a98a --- /dev/null +++ b/test/test_coverage_paths.py @@ -0,0 +1,351 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Behaviour of less travelled code paths: error branches, optional backends and fallbacks.""" + +import sys +import types + +import pytest + +import box.converters as converters +import box.from_file as from_file +from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox, box_from_file, box_from_string +from box.box import _parse_box_dots +from box.exceptions import BoxTypeError + + +@pytest.fixture +def fake_ipython(monkeypatch): + module = types.ModuleType("IPython") + module.get_ipython = lambda: object() + monkeypatch.setitem(sys.modules, "IPython", module) + return module + + +class TestBoxPaths: + def test_ipython_probes_are_not_defaulted(self, fake_ipython): + b = Box(default_box=True) + assert b.getdoc is None + assert b.shape is None + assert b.other == Box() + + def test_ipython_installed_but_not_running(self, fake_ipython, monkeypatch): + monkeypatch.setattr(fake_ipython, "get_ipython", lambda: None) + assert Box(default_box=True).shape == Box() + + def test_parse_box_dots_without_separator(self): + with pytest.raises(BoxError): + _parse_box_dots(Box(), "nodots") + + def test_tuple_holding_box_list_to_dict(self): + b = Box({"a": (BoxList([1, {"x": 1}]), Box(y=2))}) + assert b.to_dict() == {"a": ([1, {"x": 1}], {"y": 2})} + assert type(b.to_dict()["a"][0]) is list + assert type(b.to_dict()["a"][0][1]) is dict + + def test_default_box_attr_function_arguments(self): + def positional(key, box_instance): + return f"{key}-{type(box_instance).__name__}" + + def keyword(*, key, box_instance): + return f"{key}:{type(box_instance).__name__}" + + assert Box(default_box=True, default_box_attr=positional).hi == "hi-Box" + assert Box(default_box=True, default_box_attr=keyword).hi == "hi:Box" + + def bad(name): + return name + + with pytest.raises(BoxError, match="can only have the arguments"): + Box(default_box=True, default_box_attr=bad).hi + + def test_create_on_get_dotted_through_non_container(self): + b = Box({"a": 5}, default_box=True, box_dots=True, default_box_create_on_get=True) + assert b["a.b"] == Box() + assert b.to_dict() == {"a": 5} + + def test_unhashable_key(self): + with pytest.raises(BoxTypeError): + Box()[["unhashable"]] + + def test_ephemeral_child_of_frozen_box(self): + b = Box(default_box=True, frozen_box=True) + child = b.missing + with pytest.raises(BoxError, match="frozen"): + child.x = 1 + assert b.to_dict() == {} + + def test_ephemeral_child_without_conversion_box(self): + b = Box(default_box=True, conversion_box=False) + b.new.key = 1 + assert b.to_dict() == {"new": {"key": 1}} + + def test_dotted_set_without_parent(self): + with pytest.raises(BoxKeyError, match="has no attribute a"): + Box(box_dots=True)["a.b"] = 1 + + def test_dotted_paths_through_non_containers(self): + b = Box({"a": 5}, box_dots=True) + with pytest.raises(BoxKeyError): + b["a.b"] + assert "a.b" not in b + b["a.b"] = 1 # the int can't hold "b", so the whole key is stored + assert b.to_dict() == {"a": 5, "a.b": 1} + del b["a.b"] + assert b.to_dict() == {"a": 5} + b2 = Box({"a": 5}, box_dots=True) + with pytest.raises(BoxKeyError): + del b2["a.b"] + + def test_dotted_contains_into_box_list(self): + b = Box({"a": [1, 2]}, box_dots=True) + assert "a.b" not in b + + def test_camel_killer_delete_non_string_key(self): + b = Box({1: "a"}, camel_killer_box=True) + with pytest.raises(BoxKeyError): + del b[2] + del b[1] + assert b == {} + + def test_merge_update_too_many_arguments(self): + with pytest.raises(BoxTypeError, match="at most 1 argument"): + Box().merge_update({"a": 1}, b=2) + + def test_setdefault_with_list_path(self): + b = Box({"a": [1, 2]}, box_dots=True) + assert b.setdefault("a[1]", 5) == 2 + assert b.to_dict() == {"a": [1, 2]} + + def test_keep_keys_non_string_key(self): + b = Box({1: "a", "camelCase": 2}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert b[1] == "a" + assert b.camel_case == 2 + + def test_operators_with_boxes(self): + assert (Box(a=1) + Box(b=2)).to_dict() == {"a": 1, "b": 2} + assert (Box(a=1) | Box(b=2)).to_dict() == {"a": 1, "b": 2} + + def test_subtract_nested_keeps_differences(self): + result = Box(a={"x": 1, "y": 2}, b=1) - Box(a={"x": 1}) + assert result.to_dict() == {"a": {"y": 2}, "b": 1} + + def test_reflected_operators_with_box(self): + assert Box(a=1).__radd__(Box(b=2)).to_dict() == {"b": 2, "a": 1} + assert Box(a=1).__ror__(Box(a=2, b=2)).to_dict() == {"a": 1, "b": 2} + + def test_ephemeral_unfrozen_child_of_frozen_box(self): + class Other(Box): + pass + + b = Box(default_box=True, frozen_box=True, default_box_attr=Other) + child = b.missing + assert type(child) is Other + with pytest.raises(BoxError, match="frozen"): + child.x = 1 + assert b.to_dict() == {} + + def test_dir_skips_keys_without_attribute_name(self): + names = dir(Box({"...": 1, "ok": 2}, box_safe_prefix="")) + assert "ok" in names and "" not in names + + def test_dir_without_conversion_box(self): + names = dir(Box({"good": 1, "not valid": 2}, conversion_box=False)) + assert "good" in names + assert "not valid" not in names and "not_valid" not in names + + +class TestBoxListPaths: + def test_tuple_indexing_into_non_list(self): + bl = BoxList([[1, 2], {"a": 1}]) + assert bl[0, 1] == 2 + with pytest.raises(BoxTypeError, match="numpy-style"): + bl[1, 0] + + def test_dotted_delete_into_non_container(self): + bl = BoxList([5], box_dots=True) + with pytest.raises(TypeError): + del bl["[0].x"] + assert bl == [5] + + +class TestConfigBoxPaths: + def test_update_non_string_and_exact_keys(self): + cb = ConfigBox({"a": 1}) + cb.update({1: "one", "a": 2}) + assert cb.to_dict() == {"a": 2, 1: "one"} + + def test_missing_dotted_key(self): + cb = ConfigBox({"a": {"b": 1}}, box_dots=True) + assert "nope.x" not in cb + assert cb["A.B"] == 1 + + def test_index_rebuilds_after_direct_dict_write(self): + cb = ConfigBox({"a": 1}) + assert "A" in cb # builds the lower case index + dict.__setitem__(cb, "Raw", 2) + cb["b"] = 3 # the index is stale: dropped and rebuilt on the next lookup + assert cb.raw == 2 and cb.B == 3 + + def test_index_rebuilds_after_direct_write_then_exact_write(self): + cb = ConfigBox({"a": 1}) + assert "A" in cb + dict.__setitem__(cb, "Raw", 2) + cb["a"] = 5 # exact key, no lookup first, so the stale index is noticed on the write + assert cb.raw == 2 and cb.A == 5 + + def test_reflected_add_on_config_box(self): + assert ({"FOO": 2} + ConfigBox({"Foo": 1, "bar": 3})).to_dict() == {"bar": 3, "Foo": 1} + + def test_index_tracks_non_string_keys(self): + cb = ConfigBox({"a": 1}) + assert "A" in cb + cb[5] = "five" + assert cb[5] == "five" and cb.A == 1 + + def test_index_invalidated_by_nested_dotted_write(self): + cb = ConfigBox(default_box=True, box_dots=True) + assert "x" not in cb + cb["a.b"] = 1 + assert cb["A.B"] == 1 + + def test_case_variants_without_conversion_box(self): + cb = ConfigBox({"Foo": 1}, conversion_box=False) + cb["FOO"] = 2 + cb.merge_update({"foo": 3}) + assert cb.to_dict() == {"foo": 3} + + def test_take_over_keeps_other_alias(self): + cb = ConfigBox({"a_b": 1, "a b": 2}) + cb["A_B"] = 3 + assert cb.to_dict() == {"a b": 2, "A_B": 3} + + def test_box_config_key_is_stored_as_data(self): + cb = ConfigBox() + cb["_box_config"] = 5 + assert dict.__getitem__(cb, "_box_config") == 5 + + def test_update_too_many_arguments(self): + with pytest.raises(BoxTypeError, match="at most 1 argument"): + ConfigBox().update({"a": 1}, {"b": 2}) + + def test_union_on_frozen_config_box(self): + cb = ConfigBox({"Foo": 1}, frozen_box=True) + result = cb | {"FOO": 2} + assert result.to_dict() == {"FOO": 2} + assert cb.to_dict() == {"Foo": 1} + + def test_list_without_strip(self): + cb = ConfigBox(items="[a, b]") + assert cb.list("items", strip=False) == ["[a", " b]"] + + +class TestConverterPaths: + @pytest.fixture + def pyyaml_only(self, monkeypatch): + if not converters.pyyaml_available: + pytest.skip("PyYAML is not installed") + monkeypatch.setattr(converters, "ruamel_available", False) + + @pytest.fixture + def no_yaml(self, monkeypatch): + monkeypatch.setattr(converters, "ruamel_available", False) + monkeypatch.setattr(converters, "pyyaml_available", False) + + def test_no_yaml_library(self, no_yaml, tmp_path): + path = tmp_path / "a.yaml" + path.write_text("a: 1\n") + with pytest.raises(BoxError, match="No YAML Parser"): + converters._to_yaml({"a": 1}) + with pytest.raises(BoxError, match="No YAML Parser"): + converters._from_yaml("a: 1") + with pytest.raises(BoxError, match="No YAML Parser"): + converters._from_yaml(filename=path) + + def test_pyyaml_file_and_loader(self, pyyaml_only, tmp_path): + import yaml + + path = tmp_path / "a.yaml" + path.write_text("a: 1\nb: [1, 2]\n") + assert Box.from_yaml(filename=path).to_dict() == {"a": 1, "b": [1, 2]} + assert Box.from_yaml(filename=path, Loader=yaml.SafeLoader).a == 1 + assert Box.from_yaml("a: 1\n", Loader=yaml.SafeLoader).a == 1 + + def test_ruamel_attrs_from_file(self, tmp_path): + if not converters.ruamel_available: + pytest.skip("ruamel.yaml is not installed") + path = tmp_path / "a.yaml" + path.write_text("a: 'x'\n") + bx = Box.from_yaml(filename=path, ruamel_attrs={"preserve_quotes": True}) + assert bx.to_yaml() == "a: 'x'\n" + + def test_ruamel_dumper_without_sort_attribute(self): + if not converters.ruamel_available: + pytest.skip("ruamel.yaml is not installed") + assert "a" in converters._to_yaml({"a": 1}, ruamel_typ="base") + + def test_toml_package_writer(self, monkeypatch, tmp_path): + written = [] + fake_toml = types.ModuleType("toml") + fake_toml.dump = lambda obj, f: written.append(obj) or f.write("a = 1\n") + fake_toml.dumps = lambda obj: "a = 1\n" + monkeypatch.setattr(converters, "toml_write_library", fake_toml) + path = tmp_path / "out.toml" + converters._to_toml({"a": 1}, filename=path) + assert path.read_text() == "a = 1\n" + assert written == [{"a": 1}] + + +class TestFromFilePaths: + def test_toon_files(self, tmp_path): + if not from_file.toon_available: + pytest.skip("toon_format is not installed") + good = tmp_path / "data.toon" + Box(a=1, b="x").to_toon(filename=good) + assert box_from_file(good).to_dict() == {"a": 1, "b": "x"} + rows = tmp_path / "rows.toon" + BoxList([{"a": 1}, {"a": 2}]).to_toon(filename=rows) + assert box_from_file(rows).to_list() == [{"a": 1}, {"a": 2}] + bad = tmp_path / "bad.toon" + bad.write_text('a: "unterminated\n') + with pytest.raises(BoxError, match="not TOON"): + box_from_file(bad) + + def test_toon_unavailable(self, tmp_path, monkeypatch): + monkeypatch.setattr(from_file, "toon_available", False) + path = tmp_path / "data.toon" + path.write_text("a: 1\n") + with pytest.raises(BoxError, match="toon"): + box_from_file(path) + with pytest.raises(BoxError, match="toon"): + box_from_string("a: 1", string_type="toon") + + def test_box_from_string_json(self): + assert box_from_string('{"a": 1}').to_dict() == {"a": 1} + assert box_from_string("[1, 2]").to_list() == [1, 2] + with pytest.raises(BoxError, match="not JSON"): + box_from_string("{nope") + + def test_box_from_string_toml(self): + assert box_from_string("a = 1", string_type="toml").to_dict() == {"a": 1} + with pytest.raises(BoxError, match="not TOML"): + box_from_string("= nope", string_type="toml") + + def test_box_from_string_yaml(self): + assert box_from_string("a: 1", string_type="yaml").to_dict() == {"a": 1} + assert box_from_string("- 1\n- 2\n", string_type="yaml").to_list() == [1, 2] + with pytest.raises(BoxError, match="not YAML"): + box_from_string("a: [1", string_type="yaml") + + def test_box_from_string_toon(self): + if not from_file.toon_available: + pytest.skip("toon_format is not installed") + assert box_from_string(Box(a=1).to_toon(), string_type="toon").to_dict() == {"a": 1} + rows = BoxList([{"a": 1}, {"a": 2}]).to_toon() + assert box_from_string(rows, string_type="toon").to_list() == [{"a": 1}, {"a": 2}] + with pytest.raises(BoxError, match="not TOON"): + box_from_string('a: "unterminated', string_type="toon") + + def test_box_from_string_unknown_type(self): + with pytest.raises(BoxError, match="Unsupported"): + box_from_string("a", string_type="xml") From 81fbe1ac3bae72e88840643ee7602b347b9e29c8 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Wed, 4 Nov 2026 08:35:43 -0500 Subject: [PATCH 57/61] Add 80 edge case tests and fix the 5 bugs they found * `in` / get() for box_dots paths through lists ('a[0].x'), and no longer treating substrings of string values as keys * IndexError on a box_dots key ending with "." with default_box * _get_property_func assumed every class attribute was a property; the msgpack / toon converters are now protected keys like the others * BoxList.__deepcopy__ of a frozen list unfroze the copied Boxes * BoxList pickling appended items before restoring box_options, so items were rebuilt with default options (and unfrozen). __reduce_ex__ now keeps the items in the state, Box 7 pickles still load through __setstate__ A sixth finding, BoxList += not converting items, stays a strict xfail: PR #347 fixes it. The setdefault box_dots fallback is gone, `in` covers it now. Co-Authored-By: Claude Opus 5.5 --- CHANGES.rst | 7 + box/box.py | 30 +- box/box_list.py | 23 +- test/test_coverage_paths.py | 22 + test/test_edge_cases.py | 1029 +++++++++++++++++++++++++++++++++++ 5 files changed, 1094 insertions(+), 17 deletions(-) create mode 100644 test/test_edge_cases.py diff --git a/CHANGES.rst b/CHANGES.rst index 759bcc2..c8df467 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -25,6 +25,13 @@ Changes * Adding #296 _box_defaults class attribute so subclasses can change Box option defaults without overriding __init__ (also #223, #210, thanks to marcelloromani, 12rambau and miversen33 for reporting) * Adding #279 camel_killer_box_keep_keys to keep the original CamelCase keys and only add snake_case attribute aliases (thanks to jacobtomlinson for the suggestion) * Adding #123 box_dots path segments made of digits also match integer keys, e.g. box['servers.2'] for {'servers': {2: ...}} (thanks to richieadler for reporting) +* Fixing ``in`` and get() returning False / None for box_dots paths through lists, e.g. 'a[0].x' in box, and ``in`` treating substrings of string values as keys ('a.b' in Box(a='xbz')) +* Fixing IndexError setting a box_dots key ending with a dot on a default_box +* Fixing AttributeError instead of BoxKeyError when setting to_msgpack, from_msgpack, to_toon or from_toon as attributes (now protected), and setting other non property class attributes +* Fixing frozen BoxList copy.deepcopy and pickle leaving the contained Boxes unfrozen +* Fixing unpickled BoxList re-creating its Boxes with default options (box_dots, box_class, default_box and so on were lost). BoxList pickles made by earlier versions still load +* Removing the tomli and toml read fallbacks, TOML is always read with tomllib (part of Python 3.11+). Writing still uses tomli-w, or the toml package if installed +* Reaching 100% line and branch test coverage, enforced in CI * Fixing Box(default_box=True) pop() of a missing key and argparse namespaces (hasattr then delattr) with default_box_create_on_get=False * Adding #269 internal-only attributes for Box subclasses via _box_internal_attrs (thanks to bwanshoom and gtkacz for the suggestion) * Adding support for Python 3.15 diff --git a/box/box.py b/box/box.py index cd8782d..4aede80 100644 --- a/box/box.py +++ b/box/box.py @@ -207,11 +207,9 @@ def _get_property_func(obj, key): :param key: property name :return: a tuple for helper functions(fget, fset, fdel). If no such property, a (None, None, None) returns """ - obj_type = type(obj) - - if not hasattr(obj_type, key): + attr = getattr(type(obj), key, None) + if not isinstance(attr, property): return None, None, None - attr = getattr(obj_type, key) return attr.fget, attr.fset, attr.fdel @@ -266,6 +264,10 @@ class Box(dict): "from_json", "from_toml", "to_toml", + "to_msgpack", + "from_msgpack", + "to_toon", + "from_toon", "merge_update", ] + [attr for attr in dir({}) if not attr.startswith("_")] @@ -430,7 +432,7 @@ def __contains__(self, item): return in_me if in_me: return True - if "." not in item: + if not self.__process_dotted_key(item): return False first_item, children = _parse_box_dots(self, item) first_item = self.__dots_int_key(first_item) @@ -438,8 +440,16 @@ def __contains__(self, item): return False it = self[first_item] if isinstance(it, Box): - children = it.__dots_int_key(children) - return isinstance(it, Iterable) and children in it + return it.__dots_int_key(children) in it + if isinstance(it, box.BoxList): + # children is the rest of the path starting with "[", e.g. "[0].x" + try: + it.__getitem__(children, _ignore_default=True) + except (KeyError, IndexError, TypeError): + return False + return True + # Other values (strings, numbers) are not traversed by box_dots lookups either + return False def keys(self, dotted: bool = False): if not dotted: @@ -782,7 +792,7 @@ def __setitem__(self, key, value): return child.__setitem__(children, value) elif self._box_config["default_box"]: self._flush_pending_parent() - if children[0] == "[": + if children.startswith("["): super().__setitem__(first_item, box.BoxList(**self.__box_config(extra_namespace=first_item))) else: super().__setitem__( @@ -1070,10 +1080,6 @@ def setdefault(self, item, default=None): if item in self: return self[item] - if self._box_config["box_dots"]: - if item in _get_dot_paths(self): - return self[item] - if isinstance(default, dict): default = self._box_config["box_class"](default, **self.__box_config(extra_namespace=item)) if isinstance(default, list): diff --git a/box/box_list.py b/box/box_list.py index 0d82cb9..259e4c1 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -5,6 +5,7 @@ from __future__ import annotations import copy +import copyreg import re from collections.abc import Iterable from os import PathLike @@ -205,16 +206,28 @@ def __copy__(self): return self.__class__((x for x in self), **self.box_options) def __deepcopy__(self, memo=None): - frozen = self.box_options.get("frozen_box") out = self.__class__(**{**self.box_options, "frozen_box": False}) memo = memo or {} memo[id(self)] = out - for k in self: - out.append(copy.deepcopy(k, memo=memo)) - if frozen: - out.__init__(**self.box_options) + items = [copy.deepcopy(k, memo=memo) for k in self] + # Filling through __init__ applies the options (frozen included) to the copied items + out.__init__(items, **self.box_options) return out + def __reduce_ex__(self, protocol): + # The default list pickling appends the items before restoring box_options, which + # re-created every item with default options. Keep the items in the state instead, + # so __setstate__ restores the options first. Self references still work because + # pickle memoizes the new list before the state is saved. + return copyreg.__newobj__, (self.__class__,), {"box_options": self.box_options, "items": list(self)} + + def __setstate__(self, state): + if "items" not in state: + # Pickled by Box 7 or earlier: the items were already appended + self.__dict__.update(state) + return + self.__init__(state["items"], **state["box_options"]) + def __hash__(self) -> int: # type: ignore[override] if self.box_options.get("frozen_box"): hashing = 98765 diff --git a/test/test_coverage_paths.py b/test/test_coverage_paths.py index 195a98a..65cb48b 100644 --- a/test/test_coverage_paths.py +++ b/test/test_coverage_paths.py @@ -169,6 +169,28 @@ def test_dotted_delete_into_non_container(self): assert bl == [5] +class TestBoxListPickleFormats: + def test_loads_box_7_pickles(self, monkeypatch): + import pickle + + # Box 7 had no __reduce_ex__: items were appended first, then the instance state restored + with monkeypatch.context() as patch: + patch.delattr(BoxList, "__reduce_ex__") + data = pickle.dumps(BoxList([1, {"a": 1}], box_dots=True), protocol=2) + out = pickle.loads(data) + assert type(out) is BoxList + assert out.to_list() == [1, {"a": 1}] + assert out.box_options["box_dots"] is True + + def test_self_referencing_items_survive_pickle(self): + import pickle + + bl = BoxList([{"a": 1}]) + bl[0].parent = bl + out = pickle.loads(pickle.dumps(bl)) + assert out[0].parent is out + + class TestConfigBoxPaths: def test_update_non_string_and_exact_keys(self): cb = ConfigBox({"a": 1}) diff --git a/test/test_edge_cases.py b/test/test_edge_cases.py new file mode 100644 index 0000000..788fda1 --- /dev/null +++ b/test/test_edge_cases.py @@ -0,0 +1,1029 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Edge case and regression tests: hidden state (pickle / copy), ephemeral default_box children, +box_dots parsing, frozen containers, merge_update, operators, converters and subclassing. +""" + +import copy +import json +import math +import pickle +import warnings + +import pytest + +from box import ( + Box, + BoxError, + BoxKeyError, + BoxList, + ConfigBox, + DDBox, + SBox, + box_from_file, +) +from box.exceptions import BoxTypeError, BoxValueError, BoxWarning + + +class ListBox(Box): + pass + + +class DotsDefaultBox(Box): + _box_defaults = {"default_box": True, "box_dots": True} + + +class ParentDefaults(Box): + _box_defaults = {"box_dots": True} + + +class ChildDefaults(ParentDefaults): + _box_defaults = {"default_box": True} + + +class TrackedBox(Box): + _box_internal_attrs = ("_meta",) + + +class PropBox(Box): + @property + def temp(self): + return self.__dict__.get("_temp") + + @temp.setter + def temp(self, value): + self.__dict__["_temp"] = value + + @temp.deleter + def temp(self): + self.__dict__.pop("_temp", None) + + def describe(self): + return "described" + + +class IntactDict(dict): + pass + + +class IntactList(list): + pass + + +class TestPickleAndCopy: + def test_pickle_nested_box_dots_keeps_working(self): + bx = Box({"a": {"b": {"c": 1}}, "l": [{"x": 1}]}, box_dots=True) + out = pickle.loads(pickle.dumps(bx)) + assert out["a.b.c"] == 1 + assert out["l[0].x"] == 1 + out["a.b.d"] = 2 + assert out.a.b.d == 2 + assert out.a._box_config["box_dots"] is True + assert out.l.box_options["box_dots"] is True + + def test_pickle_frozen_stays_frozen_and_hashable(self): + bx = Box({"a": [1, {"b": 2}], "c": 3}, frozen_box=True) + out = pickle.loads(pickle.dumps(bx)) + assert out == bx + assert hash(out) == hash(bx) + assert isinstance(out.a, tuple) + with pytest.raises(BoxError): + out.c = 4 + with pytest.raises(BoxError): + out.a[1].b = 5 + + def test_pickle_config_box_keeps_case_insensitivity(self): + cfg = ConfigBox({"Host": "h", "sub": {"Port": 1}}) + assert cfg.host == "h" # builds the case index before pickling + out = pickle.loads(pickle.dumps(cfg)) + assert type(out) is ConfigBox + assert type(out.sub) is ConfigBox + assert out["HOST"] == "h" + assert out.SUB.port == 1 + out["HOST"] = "other" + assert list(out) == ["sub", "HOST"] + + @pytest.mark.parametrize("module", [pickle, copy]) + def test_subclass_defaults_survive_roundtrip(self, module): + bx = DotsDefaultBox({"n": {"x": 1}}) + out = pickle.loads(pickle.dumps(bx)) if module is pickle else copy.deepcopy(bx) + assert type(out) is DotsDefaultBox + assert type(out.n) is DotsDefaultBox + assert out["n.x"] == 1 + assert out.missing.deeper is not None + assert "missing" not in out + + def test_pickle_ephemeral_child_drops_parent_reference(self): + parent = Box(default_box=True) + child = parent.ghost + assert "__pending_parent" in child._box_config + data = pickle.dumps(child) + assert b"__pending_parent" not in data + out = pickle.loads(data) + assert "__pending_parent" not in out._box_config + out.x = 1 + assert out == {"x": 1} + assert "ghost" not in parent + + def test_copy_deepcopy_and_pickle_internal_attrs(self): + bx = TrackedBox({"a": 1}) + bx._meta = {"seen": [1]} + assert "_meta" not in bx + assert bx.to_dict() == {"a": 1} + shallow = copy.copy(bx) + deep = copy.deepcopy(bx) + unpickled = pickle.loads(pickle.dumps(bx)) + assert shallow._meta is bx._meta + assert deep._meta == bx._meta and deep._meta is not bx._meta + assert unpickled._meta == {"seen": [1]} + for each in (shallow, deep, unpickled): + assert type(each) is TrackedBox + assert each == {"a": 1} + + @pytest.mark.parametrize("how", ["pickle", "deepcopy"]) + def test_self_referencing_boxlist_roundtrip(self, how): + bl = BoxList([1, {"a": 2}]) + bl.append(bl) + out = pickle.loads(pickle.dumps(bl)) if how == "pickle" else copy.deepcopy(bl) + assert out is not bl + assert out[2] is out + assert out[1].a == 2 + as_list = out.to_list() + assert as_list[2] is as_list + + def test_frozen_boxlist_pickle_copy_deepcopy_refuse_list_mutation(self): + bl = BoxList([1, {"a": [2, 3]}], frozen_box=True) + for out in (pickle.loads(pickle.dumps(bl)), copy.copy(bl), copy.deepcopy(bl)): + assert out == bl + with pytest.raises(BoxError): + out.append(1) + with pytest.raises(BoxError): + out[0] = 2 + assert hash(copy.copy(bl)) == hash(bl) + + def test_frozen_boxlist_pickle_and_deepcopy_keep_items_frozen(self): + bl = BoxList([{"a": [2, 3]}], frozen_box=True) + for out in (pickle.loads(pickle.dumps(bl)), copy.deepcopy(bl)): + assert hash(out) == hash(bl) + with pytest.raises(BoxError): + out[0].a = 1 + + def test_pickle_keeps_options_of_boxes_inside_lists(self): + bx = Box({"l": [{"a": {"b": 1}}]}, box_dots=True) + out = pickle.loads(pickle.dumps(bx)) + assert out.l[0]._box_config["box_dots"] is True + standalone = BoxList([{"a": 1}], box_class=ListBox, default_box=True) + again = pickle.loads(pickle.dumps(standalone)) + assert type(again[0]) is ListBox + assert again[0]._box_config["default_box"] is True + + +class TestEphemeralDefaultBox: + def test_chained_assignment_creates_every_parent(self): + bx = Box(default_box=True) + bx.a.b.c = 1 + bx.a.b.d.e = 2 + bx["x"].y["z"] = 3 + assert bx == {"a": {"b": {"c": 1, "d": {"e": 2}}}, "x": {"y": {"z": 3}}} + + def test_lookups_never_store_and_look_empty(self): + bx = Box({"real": 1}, default_box=True) + ghost = bx.a.b.c + assert not ghost + assert len(ghost) == 0 + assert "x" not in ghost + assert ghost == {} + assert ghost == Box() + assert bx["q"] == {} + assert bx.get("w") == {} + assert bx == {"real": 1} + assert "a" not in bx + + def test_stale_child_does_not_overwrite_real_value(self): + bx = Box(default_box=True) + stale = bx.a + bx.a = {"k": 1} + stale.z = 2 + assert bx.a == {"k": 1} + assert stale == {"z": 2} + + def test_child_stored_elsewhere_is_copied_not_aliased(self): + bx = Box(default_box=True) + child = bx.a + bx.other = child + child.x = 1 + assert bx.other == {} + assert bx.a == {"x": 1} + + def test_box_dots_missing_list_and_dict_paths_are_created_on_write(self): + bx = DDBox() + assert bx["rows[3].name"] == {} + assert bx == {} + bx["rows[1].name"] = "x" + bx["a.b.c"] = 1 + assert bx.rows == [None, {"name": "x"}] + assert bx["a.b.c"] == 1 + assert isinstance(bx.rows, BoxList) + + def test_frozen_default_box_refuses_child_writes(self): + bx = Box({"a": 1}, default_box=True, frozen_box=True) + with pytest.raises(BoxError): + bx.missing.x = 1 + with pytest.raises(BoxError): + bx["m"].n = 1 + assert bx == {"a": 1} + + def test_update_and_merge_update_on_ephemeral_child_attach_it(self): + bx = Box(default_box=True) + bx.a.merge_update({"x": {"y": 1}}) + bx.b.update(z=2) + bx.c.update({}) + assert bx == {"a": {"x": {"y": 1}}, "b": {"z": 2}} + + def test_pop_delattr_and_pop_default_are_noops_for_missing_keys(self): + bx = Box({"keep": 1}, default_box=True) + assert bx.pop("nope") == {} + assert bx.pop("nope", 5) == 5 + assert hasattr(bx, "ghost") + delattr(bx, "ghost") + with pytest.raises(BoxKeyError): + del bx["ghost"] + assert bx == {"keep": 1} + + +class TestBoxDots: + def test_negative_and_out_of_range_list_indexes(self): + bx = Box({"a": [1, 2, 3]}, box_dots=True) + assert bx["a[2]"] == 3 + with pytest.raises(IndexError): + bx["a[10]"] + with pytest.raises(BoxTypeError): + bx["a[-1]"] + with pytest.raises(BoxTypeError): + bx["a[x]"] + + def test_nested_lists_get_set_delete(self): + bx = Box({"a": [[1, 2], [3, {"y": 4}]]}, box_dots=True) + assert bx["a[0][1]"] == 2 + assert bx["a[1][1].y"] == 4 + bx["a[1][1].y"] = 5 + bx["a[0][0]"] = {"n": 1} + assert bx.a[1][1].y == 5 + assert isinstance(bx.a[0][0], Box) + del bx["a[1][1].y"] + assert bx.a[1][1] == {} + del bx["a[0]"] + assert len(bx.a) == 1 + + def test_keys_dotted_are_all_resolvable(self): + bx = Box({"a": {"b": 1, "c": [1, {"d": 2}, [3]]}, "e": 2}, box_dots=True) + keys = bx.keys(dotted=True) + assert keys == ["a.b", "a.c[0]", "a.c[1].d", "a.c[2][0]", "e"] + for key in keys: + assert bx[key] is not None + assert dict(bx.items(dotted=True)) == {"a.b": 1, "a.c[0]": 1, "a.c[1].d": 2, "a.c[2][0]": 3, "e": 2} + with pytest.raises(BoxError): + Box({"a": 1}).keys(dotted=True) + + def test_contains_agrees_with_dotted_lookup_through_lists(self): + bx = Box({"a": [{"x": 1}], "b": {"c": 1}}, box_dots=True) + for key in bx.keys(dotted=True): + assert bx[key] is not None + assert key in bx, key + + def test_get_agrees_with_getitem_for_list_paths(self): + bx = Box({"a": [{"x": 1}]}, box_dots=True) + assert bx["a[0].x"] == 1 + assert bx.get("a[0].x") == 1 + + def test_box_dots_exclude_keeps_literal_dotted_keys(self): + bx = Box({"v1.0": 1, "a": {"b": 2}}, box_dots=True, box_dots_exclude=r"v\d") + assert bx["v1.0"] == 1 + assert bx["a.b"] == 2 + assert "v1.0" in bx + bx["v2.0"] = 5 + assert dict.__contains__(bx, "v2.0") + assert list(bx) == ["v1.0", "a", "v2.0"] + + def test_dotted_write_without_parent_needs_default_box(self): + with pytest.raises(BoxKeyError): + Box(box_dots=True)["a.b"] = 1 + with pytest.raises(BoxKeyError): + Box({"a.b": 1}, box_dots=True) + bx = Box(box_dots=True, default_box=True) + bx["a.b"] = 1 + bx["x..y"] = 2 + assert bx == {"a": {"b": 1}, "x": {"": {"y": 2}}} + + def test_trailing_dot_key_with_default_box_does_not_crash(self): + bx = Box(box_dots=True, default_box=True) + bx["a."] = 1 + assert bx.to_dict() == {"a": {"": 1}} + + def test_setdefault_get_and_pop_with_dotted_keys(self): + bx = Box({"a": {"b": 1}, "l": [{"k": 1}]}, box_dots=True) + assert bx.setdefault("a.c", 5) == 5 + assert bx.setdefault("a.b", 99) == 1 + assert bx.setdefault("l[0].k", 99) == 1 + assert bx.get("a.zz", 9) == 9 + assert type(bx.get("a.zz", {"q": 1})) is Box + assert bx.pop("a.b") == 1 + assert bx.pop("a.b", "gone") == "gone" + with pytest.raises(BoxKeyError): + bx.pop("a.b") + assert bx.a == {"c": 5} + + def test_integer_path_segments_only_match_within_dotted_paths(self): + bx = Box({"a": {2: "two", "3": "str3", 3: "int3"}, 7: "seven"}, box_dots=True) + assert bx["a.2"] == "two" + assert bx["a.3"] == "str3" + assert "a.2" in bx + assert "a.9" not in bx + with pytest.raises(BoxKeyError): + bx["a"]["2"] + bx["a.2"] = "TWO" + assert bx.a[2] == "TWO" + del bx["a.2"] + assert 2 not in bx.a + assert bx[7] == "seven" + assert "7" not in bx + + +class TestConversionBox: + def test_duplicate_detection_warn_error_and_ignore(self): + with pytest.raises(BoxError): + Box({"a b": 1, "a_b": 2}, box_duplicates="error") + with pytest.warns(BoxWarning): + Box({"a b": 1, "a_b": 2}, box_duplicates="warn") + with warnings.catch_warnings(): + warnings.simplefilter("error") + quiet = Box({"a b": 1, "a_b": 2}) + assert len(quiet) == 2 + with pytest.raises(BoxError): + Box(box_duplicates="error", conversion_box=False) + + def test_keywords_digits_and_unicode_keys_get_safe_aliases(self): + bx = Box({"class": 1, "def": 2, "1abc": 3, "ключ": 4, "naïve key": 5, "x-y": 6}) + assert bx.xclass == 1 + assert bx.xdef == 2 + assert bx.x1abc == 3 + assert bx.ключ == 4 + assert bx.naïve_key == 5 + assert bx.x_y == 6 + assert bx["class"] == 1 + dirs = dir(bx) + assert "xclass" in dirs and "ключ" in dirs and "class" not in dirs + + def test_deleting_a_key_releases_its_alias(self): + bx = Box({"a b": 1}, box_duplicates="error") + assert bx.a_b == 1 + del bx["a b"] + with pytest.raises(BoxKeyError): + bx.a_b + bx["a_b"] = 2 + assert bx.a_b == 2 + bx.clear() + bx["a b"] = 3 + assert bx.a_b == 3 + + def test_protected_names_stay_methods_but_work_as_keys(self): + bx = Box() + with pytest.raises(BoxKeyError): + bx.keys = 1 + with pytest.raises(BoxKeyError): + bx.to_dict = 1 + bx["keys"] = 1 + bx["update"] = 2 + assert bx["keys"] == 1 + assert callable(bx.keys) + assert callable(bx.update) + assert sorted(bx.keys()) == ["keys", "update"] + with pytest.raises(BoxKeyError): + del bx.keys + with pytest.raises(BoxError): + del bx._box_config + + def test_setting_method_names(self): + # Box's own converters are protected keys + for name in ("to_msgpack", "from_msgpack", "to_toon", "from_toon", "to_json"): + with pytest.raises(BoxKeyError, match="protected"): + setattr(Box(), name, 1) + + # Other class attributes are stored as keys, the method still wins for attribute access + class Described(Box): + label = "class attribute" + + def describe(self): + return "method" + + bx = Described() + bx.describe = 1 + bx.label = 2 + assert bx.to_dict() == {"describe": 1, "label": 2} + assert bx.describe() == "method" + + +class TestFrozen: + def test_hash_equality_and_unhashable_mutable(self): + one = Box({"a": [1, {"b": 2}], "c": "x"}, frozen_box=True) + two = Box({"a": [1, {"b": 2}], "c": "x"}, frozen_box=True) + assert one == two and hash(one) == hash(two) + assert {one: 1}[two] == 1 + assert len({one, two}) == 1 + with pytest.raises(BoxTypeError): + hash(Box(a=1)) + with pytest.raises(TypeError): + hash(BoxList([1])) + assert hash(BoxList([1, 2], frozen_box=True)) == hash(BoxList([1, 2], frozen_box=True)) + + def test_every_mutator_is_refused_and_leaves_data_intact(self): + bx = Box({"a": 1, "n": {"m": 1}}, frozen_box=True) + attempts = [ + lambda: bx.__setitem__("b", 1), + lambda: setattr(bx, "b", 1), + lambda: delattr(bx, "a"), + lambda: bx.__delitem__("a"), + lambda: bx.pop("a"), + lambda: bx.popitem(), + lambda: bx.clear(), + lambda: bx.update(b=1), + lambda: bx.merge_update({"b": 1}), + lambda: bx.merge_update({"n": {"m": 2}}), + lambda: bx.setdefault("zz", 1), + lambda: bx.n.__setitem__("m", 2), + lambda: bx.n.update({"m": 2}), + ] + for attempt in attempts: + with pytest.raises(BoxError): + attempt() + with pytest.raises(BoxError): + bx |= {"b": 1} + with pytest.raises(BoxError): + bx += {"b": 1} + assert bx == {"a": 1, "n": {"m": 1}} + + def test_frozen_boxlist_refuses_every_mutator(self): + bl = BoxList([3, 1, {"a": 1}], frozen_box=True) + attempts = [ + lambda: bl.append(1), + lambda: bl.extend([1]), + lambda: bl.insert(0, 1), + lambda: bl.pop(), + lambda: bl.remove(3), + lambda: bl.reverse(), + lambda: bl.sort(key=str), + lambda: bl.clear(), + lambda: bl.__setitem__(0, 1), + lambda: bl.__setitem__(slice(0, 1), [1]), + lambda: bl.__delitem__(0), + lambda: bl.__iadd__([1]), + lambda: bl.__imul__(2), + ] + for attempt in attempts: + with pytest.raises(BoxError): + attempt() + assert bl == [3, 1, {"a": 1}] + + @pytest.mark.parametrize( + "loader", + [ + lambda text, **kw: Box.from_json(text, **kw), + lambda text, **kw: Box.from_yaml(text, **kw), + ], + ids=["json", "yaml"], + ) + def test_frozen_loaded_from_text_serializes_back(self, loader): + text = json.dumps({"a": [1, {"b": [2, 3]}], "c": {"d": [{"e": 1}]}}) + bx = loader(text, frozen_box=True) + assert isinstance(bx.a, tuple) + assert hash(bx) == hash(loader(text, frozen_box=True)) + assert json.loads(bx.to_json()) == json.loads(text) + assert Box.from_yaml(bx.to_yaml()).to_dict() == json.loads(text) + with pytest.raises(BoxError): + bx.c.d[0].e = 2 + + def test_operators_on_frozen_boxes_return_new_frozen_boxes(self): + frozen = Box({"a": 1, "n": {"x": 1}}, frozen_box=True) + for result in (frozen + {"b": 2}, frozen | {"b": 2}, {"b": 2} + frozen, {"b": 2} | frozen): + assert result._box_config["frozen_box"] is True + assert result["b"] == 2 and result["a"] == 1 + with pytest.raises(BoxError): + result.c = 1 + assert (frozen - {"a": 1})._box_config["frozen_box"] is True + assert frozen == {"a": 1, "n": {"x": 1}} + mutable = Box(m=1) + frozen + mutable.k = 1 + assert mutable._box_config["frozen_box"] is False + + +class TestMergeUpdate: + def test_list_strategies(self): + def merged(strategy): + bx = Box({"l": [1, 2], "d": [{"a": 1}]}) + bx.merge_update({"l": [2, 3], "d": [{"b": 2}, {"c": 3}]}, box_merge_lists=strategy) + return bx.to_dict() + + assert merged(None) == {"l": [2, 3], "d": [{"b": 2}, {"c": 3}]} + assert merged(False) == {"l": [2, 3], "d": [{"b": 2}, {"c": 3}]} + assert merged("extend") == {"l": [1, 2, 2, 3], "d": [{"a": 1}, {"b": 2}, {"c": 3}]} + assert merged("unique") == {"l": [1, 2, 3], "d": [{"a": 1}, {"b": 2}, {"c": 3}]} + assert merged("merge") == {"l": [2, 3], "d": [{"a": 1, "b": 2}, {"c": 3}]} + + def test_merge_strategy_applies_to_nested_boxes_and_nested_lists(self): + bx = Box({"a": {"b": {"l": [[1, {"x": 1}], 5]}}}) + bx.merge_update({"a": {"b": {"l": [[9, {"y": 2}, 7], {"z": 1}]}}}, box_merge_lists="merge") + assert bx.to_dict() == {"a": {"b": {"l": [[9, {"x": 1, "y": 2}, 7], {"z": 1}]}}} + assert isinstance(bx.a.b.l[0][1], Box) + + def test_unknown_strategy_is_rejected_before_any_change(self): + bx = Box({"a": 1, "l": [1]}) + for bad in ("replace", "Extend", True, 1): + with pytest.raises(BoxValueError): + bx.merge_update({"a": 2, "l": [2]}, box_merge_lists=bad) + assert bx == {"a": 1, "l": [1]} + + def test_merging_dicts_and_lists_into_incompatible_values(self): + bx = Box({"num": 1, "txt": "s", "lst": [1], "dct": {"a": 1}}) + bx.merge_update({"num": {"n": 1}, "txt": [1], "lst": {"k": 1}, "dct": [1]}, box_merge_lists="extend") + assert bx == {"num": {"n": 1}, "txt": [1], "lst": {"k": 1}, "dct": [1]} + assert isinstance(bx.num, Box) and isinstance(bx.txt, BoxList) + + def test_merge_with_itself_and_with_its_dict_is_idempotent(self): + bx = Box({"a": {"b": [1, {"c": 1}]}, "d": 1}) + before = bx.to_dict() + bx.merge_update(bx) + assert bx.to_dict() == before + bx.merge_update(bx.to_dict(), box_merge_lists="merge") + assert bx.to_dict() == before + bx += bx + assert bx.to_dict() == before + + def test_merge_update_argument_forms(self): + bx = Box({"a": {"x": 1}}) + bx.merge_update([("b", 1), ("a", {"y": 2})]) + bx.merge_update(iter([("c", {"d": 1})])) + bx.merge_update(e={"f": 1}) + bx.merge_update({}) + bx.merge_update() + assert bx == {"a": {"x": 1, "y": 2}, "b": 1, "c": {"d": 1}, "e": {"f": 1}} + with pytest.raises(BoxTypeError): + bx.merge_update({"z": 1}, y=2) + with pytest.raises(BoxTypeError): + bx.merge_update({"z": 1}, {"y": 2}) + assert "z" not in bx + + def test_box_intact_types_are_not_converted_or_merged(self): + bx = Box({"d": {"a": 1}}, box_intact_types=(IntactDict, IntactList)) + bx.merge_update({"d": IntactDict(b=2), "l": IntactList([{"x": 1}])}) + assert type(bx.d) is IntactDict and bx.d == {"b": 2} + assert type(bx.l) is IntactList and type(bx.l[0]) is dict + bx.merge_update({"l": IntactList([{"y": 1}])}, box_merge_lists="extend") + assert type(bx.l) is IntactList and bx.l == [{"y": 1}] + + +class TestOperators: + def test_add_merges_deeply_and_right_side_wins(self): + left = Box({"a": {"x": 1, "y": 1}, "k": 1}) + right = {"a": {"y": 2}, "z": 3} + assert left + right == {"a": {"x": 1, "y": 2}, "k": 1, "z": 3} + assert right + left == {"a": {"x": 1, "y": 1}, "k": 1, "z": 3} + assert list(left + right) == ["a", "k", "z"] + assert left == {"a": {"x": 1, "y": 1}, "k": 1} + assert right == {"a": {"y": 2}, "z": 3} + + def test_sub_is_recursive_and_requires_a_mapping(self): + bx = Box({"a": {"x": 1, "y": 2}, "b": 1, "c": {"z": 1}}) + assert bx - {"a": {"x": 1}, "b": 1, "c": {"z": 1}} == {"a": {"y": 2}} + assert bx - Box() == bx + assert bx - bx == {} + with pytest.raises(BoxError): + bx - [("a", 1)] + assert bx == {"a": {"x": 1, "y": 2}, "b": 1, "c": {"z": 1}} + + def test_non_mappings_are_rejected_with_type_error(self): + bx = Box(a=1) + for other in ([("b", 1)], "text", 5, None, (("b", 1),)): + with pytest.raises(BoxTypeError): + bx + other + with pytest.raises(BoxTypeError): + other + bx + with pytest.raises(BoxTypeError): + bx | other + with pytest.raises(BoxTypeError): + other | bx + with pytest.raises(BoxTypeError): + bx.__iadd__(other) + with pytest.raises(BoxTypeError): + bx.__ior__(other) + assert bx == {"a": 1} + + def test_inplace_operators_keep_identity_and_class(self): + bx = Box({"a": {"x": 1}}) + ident = id(bx) + nested = bx.a + bx += {"a": {"y": 2}} + assert id(bx) == ident and bx.a is nested and nested == {"x": 1, "y": 2} + bx |= {"a": {"z": 3}} + assert id(bx) == ident and bx.a == {"z": 3} + assert type(bx.a) is Box + + def test_results_keep_the_class_and_options_of_the_box_operand(self): + cfg = ConfigBox({"Key": {"Inner": 1}}) + for result in (cfg + {"other": {"x": 1}}, cfg | {"other": {"x": 1}}, {"o": {"x": 1}} + cfg, {"o": 1} | cfg): + assert type(result) is ConfigBox + assert result.key.inner == 1 + sbx = SBox({"a": 1}, default_box=True) + for result in (sbx + {"b": {"c": 1}}, sbx | {"b": {"c": 1}}): + assert type(result) is SBox and type(result.b) is SBox + assert result.missing == {} + assert "missing" not in result + + +class TestConverters: + def test_json_roundtrip_unicode_none_empty_and_encoding(self, tmp_path): + data = {"ключ": "значение", "emoji": "😀", "none": None, "e1": {}, "e2": [], "l": [{"a": [{"b": None}]}]} + bx = Box(data) + assert Box.from_json(bx.to_json()).to_dict() == data + assert "😀" in bx.to_json() + assert "\\u" in bx.to_json(ensure_ascii=True) + for target in (tmp_path / "a.json", str(tmp_path / "b.json")): + assert bx.to_json(filename=target) is None + assert Box.from_json(filename=target).to_dict() == data + path = tmp_path / "utf16.json" + bx.to_json(filename=path, encoding="utf-16") + assert Box.from_json(filename=path, encoding="utf-16") == data + with pytest.raises(UnicodeError): + Box.from_json(filename=path, encoding="utf-8") + + def test_yaml_roundtrip_keeps_strings_that_look_like_other_types(self, tmp_path): + data = {"s1": "1.0", "s2": "true", "s3": "null", "s4": "0x10", "s5": "", "n": None, "u": "naïve ключ"} + data["l"] = [{"a": [], "b": {}}, [1, [2, {"c": "yes"}]]] + bx = Box(data) + assert Box.from_yaml(bx.to_yaml()).to_dict() == data + path = tmp_path / "out.yaml" + bx.to_yaml(filename=path) + assert Box.from_yaml(filename=str(path)).to_dict() == data + assert list(Box.from_yaml("z: 1\na: 2\nm: 3")) == ["z", "a", "m"] + + def test_yaml_scalars_load_as_builtin_types(self): + bx = Box.from_yaml("f: 1.5\ni: 0x10\nb: true\ns: '1.5'\nd: {x: [1.25, 2]}\nn: ~") + assert type(bx.f) is float + assert type(bx.i) is int and bx.i == 16 + assert type(bx.b) is bool + assert type(bx.s) is str and bx.s == "1.5" + assert type(bx.d.x[0]) is float and type(bx.d.x[1]) is int + assert bx.n is None + assert type(bx) is Box and type(bx.d) is Box and type(bx.d.x) is BoxList + + def test_toml_roundtrip_and_unsupported_none(self, tmp_path): + data = {"title": "naïve ключ", "tbl": {"a": 1, "arr": [1, 2]}, "items": [{"n": "x"}, {"n": "y"}], "e": {}} + bx = Box(data) + assert Box.from_toml(bx.to_toml()).to_dict() == data + path = tmp_path / "out.toml" + bx.to_toml(filename=path) + assert Box.from_toml(filename=path).to_dict() == data + with pytest.raises(TypeError): + Box(a=None).to_toml() + + def test_msgpack_roundtrip_including_bytes_and_boxlist(self, tmp_path): + data = {"b": b"\x00\x01", "u": "ключ", "n": None, "f": 1.5, "l": [{"a": [1, {"b": True}]}], "e": {}} + bx = Box(data) + assert Box.from_msgpack(bx.to_msgpack()).to_dict() == data + path = tmp_path / "out.msgpack" + bx.to_msgpack(filename=path) + assert Box.from_msgpack(filename=path).to_dict() == data + bl = BoxList([{"a": 1}, [2, {"b": 3}], None]) + assert BoxList.from_msgpack(bl.to_msgpack()) == bl + with pytest.raises(BoxError): + Box.from_msgpack(BoxList([1]).to_msgpack()) + with pytest.raises(BoxError): + BoxList.from_msgpack(Box(a=1).to_msgpack()) + + def test_toon_roundtrip_and_type_mismatch(self, tmp_path): + data = {"name": "naïve", "tags": ["a", "b"], "rows": [{"id": 1, "v": "x"}, {"id": 2, "v": "y"}], "n": None} + bx = Box(data) + assert Box.from_toon(bx.to_toon()).to_dict() == data + path = tmp_path / "out.toon" + bx.to_toon(filename=path) + assert Box.from_toon(filename=path).to_dict() == data + bl = BoxList([{"a": 1}, {"a": 2}]) + assert BoxList.from_toon(bl.to_toon()) == bl + with pytest.raises(BoxError): + BoxList.from_toon(bx.to_toon()) + + def test_csv_roundtrip_quoting_unicode_and_errors(self, tmp_path): + rows = BoxList([{"a": "x,y", "b": 'say "hi"', "c": "line\nbreak"}, {"a": "ключ", "b": "", "c": "1"}]) + text = rows.to_csv() + back = BoxList.from_csv(text) + assert back == rows + assert all(type(row) is Box for row in back) + path = tmp_path / "out.csv" + rows.to_csv(filename=path) + assert BoxList.from_csv(filename=path) == rows + assert BoxList([{"n": 1}]).to_csv().splitlines() == ["n", "1"] + assert BoxList.from_csv(BoxList([{"n": 1}]).to_csv())[0].n == "1" + with pytest.raises(BoxError): + BoxList([{"a": 1}, {"b": 2}]).to_csv() + with pytest.raises(BoxError): + BoxList.from_csv(filename=tmp_path / "missing.csv") + + def test_special_floats_roundtrip(self): + bx = Box(pos=math.inf, neg=-math.inf, nan=math.nan, small=5e-324, big=1.7976931348623157e308) + for back in ( + Box.from_json(bx.to_json()), + Box.from_yaml(bx.to_yaml()), + Box.from_toml(bx.to_toml()), + Box.from_msgpack(bx.to_msgpack()), + ): + assert back.pos == math.inf and back.neg == -math.inf + assert math.isnan(back.nan) + assert back.small == 5e-324 and back.big == 1.7976931348623157e308 + assert type(back.pos) is float + + def test_box_from_file_errors_and_overrides(self, tmp_path): + with pytest.raises(BoxError, match="does not exist"): + box_from_file(tmp_path / "nope.json") + with pytest.raises(BoxError, match="unknown type"): + box_from_file(self._write(tmp_path / "a.xyz", "{}")) + with pytest.raises(BoxError, match="not JSON"): + box_from_file(self._write(tmp_path / "bad.json", "not json at all")) + yaml_in_json = self._write(tmp_path / "data.json", "a: 1\nb: [1, 2]\n") + assert box_from_file(yaml_in_json, file_type="YAML") == {"a": 1, "b": [1, 2]} + upper = self._write(tmp_path / "UP.JSON", '{"a": {"b": 1}}') + loaded = box_from_file(upper, box_dots=True, frozen_box=True) + assert loaded["a.b"] == 1 + with pytest.raises(BoxError): + loaded.c = 1 + assert isinstance(box_from_file(self._write(tmp_path / "l.json", '[1, {"a": 2}]')), BoxList) + assert box_from_file(str(upper)) == {"a": {"b": 1}} + + @staticmethod + def _write(path, text): + path.write_text(text, encoding="utf-8") + return path + + +class TestConfigBox: + def test_bool_transform_values_defaults_and_missing(self): + cfg = ConfigBox(yes="yes", no="No", f="F", zero="0", one="1", false="FALSE", empty="", real=False, num=0, two=2) + for name in ("yes", "one", "two"): + assert cfg.bool(name) is True + for name in ("no", "f", "zero", "false", "empty", "real", "num"): + assert cfg.bool(name) is False + assert cfg.bool("missing", True) is True + assert cfg.bool("missing", False) is False + assert cfg.getboolean("YES") is True + with pytest.raises(BoxKeyError): + cfg.bool("missing") + + def test_list_transform_options(self): + cfg = ConfigBox(a=" 1, 2 ,3 ", b="[x;y]", c="5") + assert cfg.list("a") == ["1", "2", "3"] + assert cfg.list("a", mod=int) == [1, 2, 3] + assert cfg.list("a", strip=False) == [" 1", " 2 ", "3 "] + assert cfg.list("b", spliter=";") == ["x", "y"] + assert cfg.list("c") == ["5"] + assert cfg.list("missing", default=["d"]) == ["d"] + with pytest.raises(BoxKeyError): + cfg.list("missing") + + def test_case_insensitive_with_nested_boxes_and_box_dots(self): + cfg = ConfigBox({"Server": {"Port": "80", "Hosts": {"Main": "a"}}}, box_dots=True) + assert cfg.server.port == "80" + assert cfg["SERVER"]["port"] == "80" + assert cfg["server.port"] == "80" + assert cfg["SERVER.hosts.MAIN"] == "a" + assert "server.hosts.main" in cfg + assert cfg.int("server.port", 0) in (80, 0) + cfg["SERVER.Port"] = "81" + assert cfg == {"Server": {"Port": "81", "Hosts": {"Main": "a"}}} + assert type(cfg.server.hosts) is ConfigBox + del cfg["server.HOSTS.main"] + assert cfg.Server.Hosts == {} + + def test_latest_write_wins_for_every_write_path(self): + cfg = ConfigBox({"Foo": 1}) + cfg["FOO"] = 2 + assert list(cfg.items()) == [("FOO", 2)] + cfg.update(foo=3) + assert list(cfg.items()) == [("foo", 3)] + cfg.merge_update({"Foo": 4}) + assert list(cfg.items()) == [("Foo", 4)] + cfg.other = 1 + cfg.FOO = 5 + assert list(cfg.items()) == [("other", 1), ("FOO", 5)] + assert ConfigBox([("a", 1), ("A", 2)]) == {"A": 2} + + def test_default_box_and_ephemeral_children_ignore_case(self): + cfg = ConfigBox(default_box=True) + cfg.Sec.a = 1 + cfg.SEC.b = 2 + cfg.sec["c"] = 3 + assert cfg == {"Sec": {"a": 1, "b": 2, "c": 3}} + stale = cfg.Other + cfg.OTHER = {"k": 1} + stale.z = 1 + assert cfg == {"Sec": {"a": 1, "b": 2, "c": 3}, "OTHER": {"k": 1}} + assert "other" in cfg and "nothing" not in cfg + + def test_frozen_config_box_reads_but_never_writes(self): + cfg = ConfigBox({"Foo": {"Bar": 1}}, frozen_box=True) + assert cfg.FOO.bar == 1 + for attempt in ( + lambda: cfg.__setitem__("foo", 2), + lambda: cfg.__setitem__("FOO", 2), + lambda: cfg.update(foo=2), + lambda: cfg.merge_update({"FOO": {"x": 1}}), + lambda: cfg.__delitem__("foo"), + lambda: cfg.foo.__setitem__("BAR", 2), + ): + with pytest.raises(BoxError): + attempt() + assert cfg == {"Foo": {"Bar": 1}} + assert hash(cfg) == hash(ConfigBox({"Foo": {"Bar": 1}}, frozen_box=True)) + + +class TestBoxListBehavior: + def test_every_insertion_path_converts_items(self): + bl = BoxList() + bl.append({"a": 1}) + bl.insert(0, [{"b": 1}]) + bl.extend([{"c": 1}, [{"d": 1}]]) + bl[1:1] = [{"e": 1}] + bl[-1] = {"f": [{"g": 1}]} + assert type(bl[0]) is BoxList and type(bl[0][0]) is Box + assert type(bl[1]) is Box and bl[1].e == 1 + assert type(bl[2]) is Box and type(bl[3]) is Box + assert type(bl[-1].f) is BoxList and type(bl[-1].f[0]) is Box + + @pytest.mark.xfail(strict=True, reason="BUG: BoxList += does not convert dicts and lists, fixed by PR #347") + def test_iadd_converts_items_like_extend(self): + bl = BoxList() + bl += [{"a": 1}, [{"b": 2}]] + assert type(bl[0]) is Box + assert type(bl[1]) is BoxList and type(bl[1][0]) is Box + + def test_box_class_propagates_to_nested_items(self): + class MyBox(Box): + pass + + bl = BoxList([{"a": {"b": [{"c": 1}]}}], box_class=MyBox) + assert type(bl[0]) is MyBox + assert type(bl[0].a) is MyBox + assert type(bl[0].a.b) is BoxList and type(bl[0].a.b[0]) is MyBox + bl.append({"z": {}}) + assert type(bl[1]) is MyBox and type(bl[1].z) is MyBox + + def test_box_options_flow_from_parent_box_to_list_items(self): + bx = Box({"l": [{"a": 1}]}, box_dots=True, default_box=True, camel_killer_box=True) + bx.l.append({"CamelKey": {"X": 1}}) + assert bx.l.box_options["box_dots"] is True + assert bx["l[1].camel_key.x"] == 1 + assert bx.l[0].missing == {} + assert "missing" not in bx.l[0] + bx["l[2].fresh"] = 1 + assert bx.l[2] == {"fresh": 1} + + def test_boxlist_copy_is_shallow_deepcopy_is_independent(self): + bl = BoxList([{"a": [1]}], box_dots=True) + shallow = copy.copy(bl) + deep = copy.deepcopy(bl) + assert shallow == bl and deep == bl + assert shallow is not bl and deep is not bl + assert shallow.box_options["box_dots"] and deep.box_options["box_dots"] + assert shallow.box_options["box_class"] is deep.box_options["box_class"] is Box + deep[0].a.append(2) + deep.append({"n": 1}) + assert bl == [{"a": [1]}] + assert deep["[0].a[1]"] == 2 + assert deep[1]._box_config["box_dots"] is True + + +class TestSubclassing: + def test_box_defaults_inherit_and_explicit_options_win(self): + child = ChildDefaults({"a": {"b": 1}}) + assert child._box_config["box_dots"] is True + assert child._box_config["default_box"] is True + assert child["a.b"] == 1 + assert ParentDefaults()._box_config["default_box"] is False + assert ChildDefaults(box_dots=False)._box_config["box_dots"] is False + assert ChildDefaults(default_box=False)._box_config["default_box"] is False + assert Box()._box_config["box_dots"] is False + assert DDBox(default_box=False)._box_config["default_box"] is False + + def test_unknown_box_default_is_rejected_at_class_creation(self): + with pytest.raises(BoxError, match="not_an_option"): + + class Bad(Box): + _box_defaults = {"not_an_option": 1} + + def test_subclass_defaults_apply_to_nested_conversion_from_json_and_yaml(self): + text = '{"a": {"b": [{"c": 1}]}}' + for bx in (ChildDefaults.from_json(text), ChildDefaults.from_yaml(text)): + assert type(bx) is ChildDefaults + assert type(bx.a) is ChildDefaults + assert type(bx.a.b[0]) is ChildDefaults + assert bx["a.b[0].c"] == 1 + assert bx.a.nothing == {} and "nothing" not in bx.a + explicit = ChildDefaults.from_json(text, box_dots=False) + assert explicit.a._box_config["box_dots"] is False + + def test_property_setter_and_deleter_are_used_not_the_data(self): + bx = PropBox({"k": 1}) + bx.temp = 5 + assert bx.temp == 5 + assert "temp" not in bx + assert bx.to_dict() == {"k": 1} + del bx.temp + assert bx.temp is None + bx["temp"] = "as key" + assert bx["temp"] == "as key" + assert bx.temp is None + assert bx.describe() == "described" + bx["describe"] = 1 + assert bx.describe() == "described" + assert bx["describe"] == 1 + + +class TestDictCompat: + def test_dict_conversion_and_equality(self): + bx = Box({"a": {"b": 1}, "l": [1]}) + flat = dict(bx) + assert type(flat) is dict and type(flat["a"]) is Box + assert bx == {"a": {"b": 1}, "l": [1]} + assert {"a": {"b": 1}, "l": [1]} == bx + assert bx == Box({"l": [1], "a": {"b": 1}}, default_box=True) + assert bx != {"a": {"b": 2}, "l": [1]} + assert bx.a == {"b": 1} and bx.l == [1] + assert bx.l == BoxList([1]) + assert bx.a != BoxList([1]) + + def test_constructor_options_are_not_data_when_passed_in_a_dict(self): + bx = Box({"frozen_box": True, "default_box": 1}) + assert not bx._box_config["frozen_box"] + assert not bx._box_config["default_box"] + assert bx == {"frozen_box": True, "default_box": 1} + bx.new = 1 + opts = Box(a=1, frozen_box=True) + assert opts == {"a": 1} + assert Box({"a": 1}, b=2) == {"a": 1, "b": 2} + assert Box([("a", 1)], b=2) == {"a": 1, "b": 2} + with pytest.raises(BoxValueError): + Box("text") + with pytest.raises(BoxValueError): + Box(5) + with pytest.raises(BoxTypeError): + Box({"a": 1}, {"b": 2}) + + def test_fromkeys_and_get_default_conversion(self): + bx = Box.fromkeys(["a", "b"], {"x": 1}) + assert type(bx) is Box and type(bx.a) is Box and bx.a is not bx.b + got = bx.get("none", {"q": [{"r": 1}]}) + assert type(got) is Box and type(got.q) is BoxList + assert type(bx.get("none", [{"r": 1}])[0]) is Box + assert bx.get("none") is None + assert bx.get("none", None) is None + assert "none" not in bx + dflt = Box(default_box=True).get("zz") + assert dflt == {} + + def test_live_views_and_reversed(self): + bx = Box(a=1, b=2) + keys, values, items = bx.keys(), bx.values(), bx.items() + bx.c = {"d": 1} + assert "c" in keys and len(keys) == 3 + assert type(list(values)[-1]) is Box + assert ("a", 1) in items + assert list(reversed(bx)) == ["c", "b", "a"] + del bx.a + assert list(keys) == ["b", "c"] + assert bx.popitem() == ("c", {"d": 1}) and bx.popitem() == ("b", 2) + with pytest.raises(BoxKeyError): + bx.popitem() + + def test_repr_and_str_of_nested_frozen_and_subclass_boxes(self): + bx = Box({"a": {"b": [1, {"c": 2}]}}) + assert repr(bx) == "Box({'a': {'b': [1, {'c': 2}]}})" + assert str(bx) == "{'a': {'b': [1, {'c': 2}]}}" + assert repr(bx.a.b) == "BoxList([1, {'c': 2}])" + assert repr(ConfigBox(a=1)) == "ConfigBox({'a': 1})" + assert repr(SBox(a=1)) == "SBox({'a': 1})" + assert repr(ChildDefaults(a=1)) == "ChildDefaults({'a': 1})" + frozen = Box({"a": [1, {"b": 2}]}, frozen_box=True) + assert repr(frozen) == "Box({'a': (1, {'b': 2})})" + assert str(Box()) == "{}" and repr(BoxList()) == "BoxList([])" + + def test_contains_with_unhashable_and_odd_keys(self): + bx = Box({"a": 1, (1, 2): "t", None: "n", 1.5: "f"}) + with pytest.raises(TypeError): + [] in bx + with pytest.raises(TypeError): + {} in bx + with pytest.raises(TypeError): + [] in Box(box_dots=True) + with pytest.raises(TypeError): + [] in ConfigBox() + assert (1, 2) in bx and None in bx and 1.5 in bx + assert bx[(1, 2)] == "t" and bx[None] == "n" + assert "a.b" not in Box({"a": 1}, box_dots=True) From b623bcc78416fc542f4da67659dd24925c9b3d87 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Wed, 4 Nov 2026 08:40:15 -0500 Subject: [PATCH 58/61] Update development dependencies to their latest versions * pyproject dependency group minimums raised to the current releases, and the pytest-cov<6 cap lifted (pytest-cov 7.1.0); uv.lock upgraded with uv 0.13.7 * Cython 3.3.1 for cibuildwheel and the publish workflow, twine 7.0.0 * pre-commit: pre-commit-hooks v6.0.0 (drops the removed fix-encoding-pragma hook), mirrors-mypy v2.4.1 with current type dependencies * Fix the 4 errors the per-file pre-commit mypy run reports (StringIO / file variable type, list operator signatures, Callable in a type comment) ruff 0.17.3 and cibuildwheel 4.3.5 were already the latest. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/pythonpublish.yml | 6 +-- .pre-commit-config.yaml | 7 ++- CHANGES.rst | 1 + box/box_list.py | 4 +- box/converters.py | 3 +- box/from_file.py | 5 ++- pyproject.toml | 28 ++++++------ uv.lock | 69 +++++++++++++++-------------- 8 files changed, 63 insertions(+), 60 deletions(-) diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index f3a52ba..3732cbb 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -36,7 +36,7 @@ jobs: - name: Build and check run: | uv build - uvx twine==6.2.0 check dist/* + uvx twine==7.0.0 check dist/* - name: Upload distribution artifact uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 @@ -70,12 +70,12 @@ jobs: - name: Install build dependencies run: | uv venv --python "${{ steps.setup-python.outputs.python-path }}" - uv pip install "setuptools>=77" wheel "Cython>=3.3.0" + uv pip install "setuptools>=77" wheel "Cython>=3.3.1" # No build isolation so the Cython installed above is used to build the compiled wheel - name: Build and check run: | uv build --wheel --no-build-isolation - uvx twine==6.2.0 check dist/* + uvx twine==7.0.0 check dist/* - name: Upload wheel artifact uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index a41dd5a..51f553f 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,6 @@ repos: - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v5.0.0 + rev: v6.0.0 hooks: # Identify invalid files - id: check-ast @@ -16,7 +16,6 @@ repos: # Python checks - id: check-docstring-first - id: debug-statements - - id: fix-encoding-pragma - id: fix-byte-order-marker # General quality checks # - id: mixed-line-ending @@ -44,8 +43,8 @@ repos: always_run: true - repo: https://github.com/pre-commit/mirrors-mypy - rev: 'v1.13.0' + rev: 'v2.4.1' hooks: - id: mypy types: [python] - additional_dependencies: [ruamel.yaml,toml,types-toml,tomli,tomli-w,msgpack,types-PyYAML] + additional_dependencies: [ruamel.yaml, tomli-w, msgpack, types-PyYAML, toon-format] diff --git a/CHANGES.rst b/CHANGES.rst index c8df467..2ec7bb3 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -32,6 +32,7 @@ Changes * Fixing unpickled BoxList re-creating its Boxes with default options (box_dots, box_class, default_box and so on were lost). BoxList pickles made by earlier versions still load * Removing the tomli and toml read fallbacks, TOML is always read with tomllib (part of Python 3.11+). Writing still uses tomli-w, or the toml package if installed * Reaching 100% line and branch test coverage, enforced in CI +* Updating development dependencies to their latest versions (pytest 9, pytest-cov 7, mypy 2, twine 7, Cython 3.3.1, pre-commit-hooks 6) * Fixing Box(default_box=True) pop() of a missing key and argparse namespaces (hasattr then delattr) with default_box_create_on_get=False * Adding #269 internal-only attributes for Box subclasses via _box_internal_attrs (thanks to bwanshoom and gtkacz for the suggestion) * Adding support for Python 3.15 diff --git a/box/box_list.py b/box/box_list.py index 259e4c1..d6e2394 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -138,12 +138,12 @@ def converted_items(): return super().__setitem__(key, converted_items()) super().__setitem__(key, self._convert(value)) - def __iadd__(self, value): + def __iadd__(self, value): # type: ignore[misc] # list accepts any iterable for +=, not only lists if self.box_options.get("frozen_box"): raise BoxError("BoxList is frozen") return super().__iadd__(value) - def __imul__(self, value): + def __imul__(self, value): # type: ignore[misc] if self.box_options.get("frozen_box"): raise BoxError("BoxList is frozen") return super().__imul__(value) diff --git a/box/converters.py b/box/converters.py index 93100ae..7c144fb 100644 --- a/box/converters.py +++ b/box/converters.py @@ -9,7 +9,7 @@ from io import StringIO from os import PathLike from pathlib import Path -from typing import Any +from typing import IO, Any from box.exceptions import BoxError @@ -375,6 +375,7 @@ def _to_csv( if list(row.keys()) != csv_column_names: raise BoxError("BoxList must contain the same dictionary structure for every item to convert to csv") + out_data: IO[str] if filename: _exists(filename, create=True) out_data = open(filename, "w", encoding=encoding, errors=errors, newline="") diff --git a/box/from_file.py b/box/from_file.py index 7323dbf..f6f2650 100644 --- a/box/from_file.py +++ b/box/from_file.py @@ -2,6 +2,7 @@ # -*- coding: utf-8 -*- from __future__ import annotations +from collections.abc import Callable from json import JSONDecodeError from os import PathLike from pathlib import Path @@ -90,7 +91,7 @@ def _to_toon(file, encoding, errors, **kwargs): return BoxList.from_toon(filename=file, encoding=encoding, errors=errors, **kwargs) -converters = { +converters: dict[str, Callable] = { "json": _to_json, "jsn": _to_json, "yaml": _to_yaml, @@ -101,7 +102,7 @@ def _to_toon(file, encoding, errors, **kwargs): "msgpack": _to_msgpack, "pack": _to_msgpack, "csv": _to_csv, -} # type: dict[str, Callable] +} def box_from_file( diff --git a/pyproject.toml b/pyproject.toml index 7056cc4..423145b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -60,26 +60,26 @@ version = { attr = "box.__version__" } [dependency-groups] # Everything the test suite needs (also used by cibuildwheel via `test-groups`) test = [ - "coverage>=7.6.9", - "msgpack>=1.0", - "pytest>=7.1.3", - "pytest-cov<6.0.0", + "coverage>=7.17.1", + "msgpack>=1.2.4", + "pytest>=9.2.0", + "pytest-cov>=7.1.0", "ruamel.yaml>=0.19.1", - "tomli-w>=1.0.0", + "tomli-w>=1.2.0", "toon-format>=1.2.0", - "types-PyYAML>=6.0.3", + "types-PyYAML>=6.0.12.20261103", ] # Development tooling: linting, type checking, building and releasing dev = [ { include-group = "test" }, - "build>=1.2", - "Cython>=3.3.0", - "mypy>=1.0.1", - "pre-commit>=2.21.0", + "build>=1.6.1", + "Cython>=3.3.1", + "mypy>=2.4.1", + "pre-commit>=4.7.0", "ruff>=0.17.3", - "setuptools>=77", - "twine>=5", - "wheel>=0.34.2", + "setuptools>=84.2.1", + "twine>=7.0.0", + "wheel>=0.48.0", ] [tool.ruff] @@ -109,7 +109,7 @@ known-first-party = ["box", "test"] [tool.cibuildwheel] build = "cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64 cp315-manylinux_x86_64" # Cython (and setuptools) must be present in the build environment, so build without isolation -before-build = "pip install 'Cython>=3.3.0' setuptools wheel" +before-build = "pip install 'Cython>=3.3.1' setuptools wheel" build-frontend = { name = "build", args = ["--no-isolation"] } build-verbosity = 1 test-groups = ["test"] diff --git a/uv.lock b/uv.lock index a0be245..bae615f 100644 --- a/uv.lock +++ b/uv.lock @@ -551,11 +551,11 @@ wheels = [ [[package]] name = "filelock" -version = "4.2.7" +version = "4.2.8" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e0/14/73688a22e91cfcfc6837a011ffa572e2ba3c348765f7bd482d8436fa9b6f/filelock-4.2.7.tar.gz", hash = "sha256:31f6f7e3a8b6f0bd89114d30c5d5218ea1cfb63e5c4aa695b7559314a209bc7f", size = 661450, upload-time = "2026-11-02T16:09:15.119Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c8/51/6619729344deb33a55ead1fbf50ac6435f43e33d6d57e56acd1495b24233/filelock-4.2.8.tar.gz", hash = "sha256:23df640ac0c3351f8d15c9739072d63be9078758b7d102a2183277ceb96605a3", size = 662554, upload-time = "2026-11-04T07:46:45.354Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/1a/1fcf0d3886bad15b92459a0e529dd86a1ec4d9ef30e789df48044fd3698c/filelock-4.2.7-py3-none-any.whl", hash = "sha256:d08972bbca2b8767ee552aff877b091dd111ffb1d22de7de885766ea7d719d5e", size = 164345, upload-time = "2026-11-02T16:09:13.588Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ee/69ac34614c54831e0c4d34b92554d4df5b7ae71173d308040d44c432351f/filelock-4.2.8-py3-none-any.whl", hash = "sha256:c2be657e2c279cb032af8e4ea8ce2e20aa982e540be77fcaa34910d068ac2510", size = 164577, upload-time = "2026-11-04T07:46:43.907Z" }, ] [[package]] @@ -1038,11 +1038,11 @@ wheels = [ [[package]] name = "platformdirs" -version = "4.14.3" +version = "4.14.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/886dc7c9d21e2d95aceb696f1e31271742033aeef3661f6e9c8921493592/platformdirs-4.14.3.tar.gz", hash = "sha256:021add1ab113483edbcd4694f5fbb2d688b893ea30d35e1155bb371cf4be0be8", size = 71124, upload-time = "2026-11-01T16:27:32.928Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/f1/602599e5879fce55f44b8021d28bd3817d87198a6be63e5c9d7e31891f0d/platformdirs-4.14.4.tar.gz", hash = "sha256:edb4a4aea570d69eb83e6b0973b588bbf868fb0dde2894106d6667739f017751", size = 71235, upload-time = "2026-11-04T07:38:46.024Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/93/41/f0aa003909ee77a9e7e55f8659abb635ca23ab0d022a449bbb18da87a1ef/platformdirs-4.14.3-py3-none-any.whl", hash = "sha256:cba2d05fe5e18b26b1fa6f376b8e6234c012abe1f8696c486fface7d0054e931", size = 35276, upload-time = "2026-11-01T16:27:31.498Z" }, + { url = "https://files.pythonhosted.org/packages/01/7c/562ddff1940562f7701a7e8b0a90a900be606af334cc5f69543293e2293a/platformdirs-4.14.4-py3-none-any.whl", hash = "sha256:89c1bfa30434b2dcc08655bcfb1789e1a6f97602c11ff990615d09a4b823d6be", size = 35357, upload-time = "2026-11-04T07:38:44.794Z" }, ] [[package]] @@ -1115,15 +1115,16 @@ wheels = [ [[package]] name = "pytest-cov" -version = "5.0.0" +version = "7.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "coverage" }, + { name = "pluggy" }, { name = "pytest" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/74/67/00efc8d11b630c56f15f4ad9c7f9223f1e5ec275aaae3fa9118c6a223ad2/pytest-cov-5.0.0.tar.gz", hash = "sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857", size = 63042, upload-time = "2024-03-24T20:16:34.856Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/78/3a/af5b4fa5961d9a1e6237b530eb87dd04aea6eb83da09d2a4073d81b54ccf/pytest_cov-5.0.0-py3-none-any.whl", hash = "sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652", size = 21990, upload-time = "2024-03-24T20:16:32.444Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, ] [[package]] @@ -1201,44 +1202,44 @@ provides-extras = ["all", "yaml", "ruamel-yaml", "pyyaml", "tomli", "toml", "msg [package.metadata.requires-dev] dev = [ - { name = "build", specifier = ">=1.2" }, - { name = "coverage", specifier = ">=7.6.9" }, - { name = "cython", specifier = ">=3.3.0" }, - { name = "msgpack", specifier = ">=1.0" }, - { name = "mypy", specifier = ">=1.0.1" }, - { name = "pre-commit", specifier = ">=2.21.0" }, - { name = "pytest", specifier = ">=7.1.3" }, - { name = "pytest-cov", specifier = "<6.0.0" }, + { name = "build", specifier = ">=1.6.1" }, + { name = "coverage", specifier = ">=7.17.1" }, + { name = "cython", specifier = ">=3.3.1" }, + { name = "msgpack", specifier = ">=1.2.4" }, + { name = "mypy", specifier = ">=2.4.1" }, + { name = "pre-commit", specifier = ">=4.7.0" }, + { name = "pytest", specifier = ">=9.2.0" }, + { name = "pytest-cov", specifier = ">=7.1.0" }, { name = "ruamel-yaml", specifier = ">=0.19.1" }, { name = "ruff", specifier = ">=0.17.3" }, - { name = "setuptools", specifier = ">=77" }, - { name = "tomli-w", specifier = ">=1.0.0" }, + { name = "setuptools", specifier = ">=84.2.1" }, + { name = "tomli-w", specifier = ">=1.2.0" }, { name = "toon-format", specifier = ">=1.2.0" }, - { name = "twine", specifier = ">=5" }, - { name = "types-pyyaml", specifier = ">=6.0.3" }, - { name = "wheel", specifier = ">=0.34.2" }, + { name = "twine", specifier = ">=7.0.0" }, + { name = "types-pyyaml", specifier = ">=6.0.12.20261103" }, + { name = "wheel", specifier = ">=0.48.0" }, ] test = [ - { name = "coverage", specifier = ">=7.6.9" }, - { name = "msgpack", specifier = ">=1.0" }, - { name = "pytest", specifier = ">=7.1.3" }, - { name = "pytest-cov", specifier = "<6.0.0" }, + { name = "coverage", specifier = ">=7.17.1" }, + { name = "msgpack", specifier = ">=1.2.4" }, + { name = "pytest", specifier = ">=9.2.0" }, + { name = "pytest-cov", specifier = ">=7.1.0" }, { name = "ruamel-yaml", specifier = ">=0.19.1" }, - { name = "tomli-w", specifier = ">=1.0.0" }, + { name = "tomli-w", specifier = ">=1.2.0" }, { name = "toon-format", specifier = ">=1.2.0" }, - { name = "types-pyyaml", specifier = ">=6.0.3" }, + { name = "types-pyyaml", specifier = ">=6.0.12.20261103" }, ] [[package]] name = "python-discovery" -version = "1.9.2" +version = "1.9.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "filelock" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ea/87/77b17c6d289a551d682826e228e3efa3199305a080541d991cb7b268a527/python_discovery-1.9.2.tar.gz", hash = "sha256:de397b9c4b09a5fb8bb4c51db3c0da71fb81d2283718d74fd1efaabffc32afbc", size = 140950, upload-time = "2026-11-03T05:04:25.117Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d7/1e94df7d1636bf00b9f261bf88a4adc0414f14931ff60511eb0f34c250d1/python_discovery-1.9.4.tar.gz", hash = "sha256:c01b45fe515c1d268b57c57d554bb0e1d320b8e9eb5490bb2f4f577be26e4380", size = 140385, upload-time = "2026-11-04T05:25:52.097Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/39/5b/d61e08d34eeb74eb88431243e3849551f0161de08659d55312955afd2a36/python_discovery-1.9.2-py3-none-any.whl", hash = "sha256:65857e689ba72aeb5517e68b7025430ed60372b78d037245e0bed3d41ae7ba65", size = 44201, upload-time = "2026-11-03T05:04:23.777Z" }, + { url = "https://files.pythonhosted.org/packages/c5/44/b248f3b1a23f44d8de172e2767748082c41cbd9353009af72f4b11b00afa/python_discovery-1.9.4-py3-none-any.whl", hash = "sha256:b468f365040b40f4cb39918b0766d3e5a2f340968e07df752fbc96f1bb4641ab", size = 44220, upload-time = "2026-11-04T05:25:50.514Z" }, ] [[package]] @@ -1500,7 +1501,7 @@ wheels = [ [[package]] name = "virtualenv" -version = "21.15.4" +version = "21.15.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "distlib" }, @@ -1509,9 +1510,9 @@ dependencies = [ { name = "platformdirs" }, { name = "python-discovery" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c3/29/766593bdf0631aed6833e0f36f9495e0aad6325ce52754977beb895a4d83/virtualenv-21.15.4.tar.gz", hash = "sha256:105b395ce731f1cd086378037c9e20fadbb2aef98836d19b6d5767f622d21de1", size = 5640989, upload-time = "2026-11-04T01:29:34.982Z" } +sdist = { url = "https://files.pythonhosted.org/packages/69/74/745e612b69ad14a534b7bc233c4574b968eb2c21a276ea172e8f0fc13f51/virtualenv-21.15.5.tar.gz", hash = "sha256:fb869ea32930530ccc87549877b53268c2a4d4a7d7f2c384042eca05170350e6", size = 5639868, upload-time = "2026-11-04T05:13:20.929Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9a/92/6789235837302508926b5a58d3f3aa098d3c294e381baed5d4cb202a6e6e/virtualenv-21.15.4-py3-none-any.whl", hash = "sha256:a66dfba5f608b3a1778d86ddf6a63a611f394934bb2cffd13ae6962b98b9798f", size = 5680750, upload-time = "2026-11-04T01:29:32.4Z" }, + { url = "https://files.pythonhosted.org/packages/9d/d6/f9ac78f115e32e0d76adda9db72b74425b86495ae274cd7b58c660f5d1c1/virtualenv-21.15.5-py3-none-any.whl", hash = "sha256:bcf98c32139cf3df7f0cc2c8c48ca150645c20e66f8c4fe6c1e5e40bcae73947", size = 5680750, upload-time = "2026-11-04T05:13:19.057Z" }, ] [[package]] From 98162a70fa1f1b02539baa98af4be208d5cac327 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Wed, 4 Nov 2026 08:45:02 -0500 Subject: [PATCH 59/61] Keep options for dict | Box and dict + Box, class factories for default_box_attr, ConfigBox "off" * __radd__ / __ror__ build the result from a plain dict with the Box's class and options (unfrozen, top level namespace), like __sub__ already did * default_box_attr: list maps to BoxList like [] does, other classes and functions are called like defaultdict factories. key / box_instance are passed by keyword (positional only parameters positionally), any other required parameter is an error * ConfigBox.bool: "off" is false, as in configparser Co-Authored-By: Claude Opus 5.5 --- CHANGES.rst | 3 ++ box/box.py | 54 ++++++++++--------- box/config_box.py | 3 +- test/test_coverage_paths.py | 2 +- test/test_review_fixes.py | 102 ++++++++++++++++++++++++++++++++++++ 5 files changed, 138 insertions(+), 26 deletions(-) create mode 100644 test/test_review_fixes.py diff --git a/CHANGES.rst b/CHANGES.rst index 2ec7bb3..d3ead4d 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -31,6 +31,9 @@ Changes * Fixing frozen BoxList copy.deepcopy and pickle leaving the contained Boxes unfrozen * Fixing unpickled BoxList re-creating its Boxes with default options (box_dots, box_class, default_box and so on were lost). BoxList pickles made by earlier versions still load * Removing the tomli and toml read fallbacks, TOML is always read with tomllib (part of Python 3.11+). Writing still uses tomli-w, or the toml package if installed +* Fixing dict | Box and dict + Box returning a Box without the right side's options (box_dots, default_box, box_class and so on) +* Fixing default_box_attr with classes such as list, int or set raising an error, they now work like defaultdict factories (list gives a BoxList). Only required parameters of a default_box_attr function have to be named key or box_instance +* Fixing ConfigBox.bool treating "off" as True, it now matches the configparser false values * Reaching 100% line and branch test coverage, enforced in CI * Updating development dependencies to their latest versions (pytest 9, pytest-cov 7, mypy 2, twine 7, Cython 3.3.1, pre-commit-hooks 6) * Fixing Box(default_box=True) pop() of a missing key and argparse namespaces (hasattr then delattr) with default_box_create_on_get=False diff --git a/box/box.py b/box/box.py index 4aede80..53fe5df 100644 --- a/box/box.py +++ b/box/box.py @@ -341,13 +341,18 @@ def __radd__(self, other: Mapping[Any, Any]): if not isinstance(other, dict): raise BoxTypeError("Box can only merge two boxes or a box and a dictionary.") - new_box = other.copy() - if not isinstance(other, Box): - new_box = self._box_config["box_class"](new_box) + new_box = other.copy() if isinstance(other, Box) else self.__new_from_plain(other) new_box.merge_update(self, _force_unfrozen=True) # type: ignore[attr-defined] new_box._box_config["frozen_box"] = self._box_config["frozen_box"] # type: ignore[attr-defined] return new_box + def __new_from_plain(self, other): + """A Box of this box's class and options (unfrozen, top level) holding a plain dict's data""" + config = self.__box_config() + config["frozen_box"] = False + config.pop("box_namespace") + return self._box_config["box_class"](other, **config) + def __iadd__(self, other: Mapping[Any, Any]): if not isinstance(other, dict): raise BoxTypeError("Box can only merge two boxes or a box and a dictionary.") @@ -366,9 +371,7 @@ def __or__(self, other: Mapping[Any, Any]): def __ror__(self, other: Mapping[Any, Any]): if not isinstance(other, dict): raise BoxTypeError("Box can only merge two boxes or a box and a dictionary.") - new_box = other.copy() - if not isinstance(other, Box): - new_box = self._box_config["box_class"](new_box) + new_box = other.copy() if isinstance(other, Box) else self.__new_from_plain(other) new_box._box_config["frozen_box"] = False # type: ignore[attr-defined] new_box.update(self) # type: ignore[attr-defined] new_box._box_config["frozen_box"] = self._box_config["frozen_box"] # type: ignore[attr-defined] @@ -570,28 +573,31 @@ def __get_default(self, item): value = self._box_config["box_class"](**self.__box_config(extra_namespace=item)) elif isinstance(default_value, dict): value = self._box_config["box_class"](**self.__box_config(extra_namespace=item), **default_value) - elif isinstance(default_value, list): + elif isinstance(default_value, list) or default_value is list: value = box.BoxList(**self.__box_config(extra_namespace=item)) elif isinstance(default_value, Callable): + # Parameters named key / box_instance receive the missing key and this box. Any other + # parameter must be optional, so plain factories such as int, set or a lambda work too. args = [] kwargs = {} - p_sigs = [ - p.name - for p in signature(default_value).parameters.values() - if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) - ] - k_sigs = [p.name for p in signature(default_value).parameters.values() if p.kind is p.KEYWORD_ONLY] - for name in p_sigs: - if name not in ("key", "box_instance"): - raise BoxError("default_box_attr can only have the arguments 'key' and 'box_instance'") - if "key" in p_sigs: - args.append(item) - if "box_instance" in p_sigs: - args.insert(p_sigs.index("box_instance"), self) - if "key" in k_sigs: - kwargs["key"] = item - if "box_instance" in k_sigs: - kwargs["box_instance"] = self + try: + params = list(signature(default_value).parameters.values()) + except (TypeError, ValueError): # pragma: no cover (callables without a readable signature) + params = [] + for param in params: + if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD): + continue + if param.name in ("key", "box_instance"): + passed = item if param.name == "key" else self + if param.kind is param.POSITIONAL_ONLY: + args.append(passed) + else: + kwargs[param.name] = passed + elif param.default is param.empty: + raise BoxError( + "default_box_attr can only have the required arguments 'key' and 'box_instance', " + f"not {param.name!r}" + ) value = default_value(*args, **kwargs) elif hasattr(default_value, "copy"): value = default_value.copy() diff --git a/box/config_box.py b/box/config_box.py index fe57b73..2bc8004 100644 --- a/box/config_box.py +++ b/box/config_box.py @@ -238,7 +238,8 @@ def bool(self, item, default=None): if isinstance(item, (bool, int)): return bool(item) - if isinstance(item, str) and item.lower() in ("n", "no", "false", "f", "0"): + # The configparser false values, plus "n" and "f" + if isinstance(item, str) and item.strip().lower() in ("n", "no", "false", "f", "0", "off"): return False return True if item else False diff --git a/test/test_coverage_paths.py b/test/test_coverage_paths.py index 65cb48b..a60b7a9 100644 --- a/test/test_coverage_paths.py +++ b/test/test_coverage_paths.py @@ -56,7 +56,7 @@ def keyword(*, key, box_instance): def bad(name): return name - with pytest.raises(BoxError, match="can only have the arguments"): + with pytest.raises(BoxError, match="only have the required arguments .key. and .box_instance., not .name."): Box(default_box=True, default_box_attr=bad).hi def test_create_on_get_dotted_through_non_container(self): diff --git a/test/test_review_fixes.py b/test/test_review_fixes.py new file mode 100644 index 0000000..2f77226 --- /dev/null +++ b/test/test_review_fixes.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Reflected operators keep options, class factories for default_box_attr, ConfigBox "off".""" + +import pytest + +from box import Box, BoxError, BoxList, ConfigBox + + +class Sub(Box): + pass + + +class TestReflectedOperatorsKeepOptions: + @pytest.mark.parametrize("op", ["|", "+"]) + def test_plain_dict_on_the_left(self, op): + right = Sub({"b": {"c": 1}}, box_dots=True, default_box=True, camel_killer_box=True) + result = {"CamelKey": 1} | right if op == "|" else {"CamelKey": 1} + right + assert type(result) is Sub + for option in ("box_dots", "default_box", "camel_killer_box"): + assert result._box_config[option] is True, option + assert result["b.c"] == 1 + assert result.camel_key == 1 + assert result.missing == Sub() + + def test_frozen_right_side(self): + right = Box({"b": 2}, frozen_box=True) + for result in ({"a": 1} | right, {"a": 1} + right): + assert result.to_dict() == {"a": 1, "b": 2} + with pytest.raises(BoxError): + result.c = 3 + assert right.to_dict() == {"b": 2} + + def test_order_rules_unchanged(self): + right = Box({"a": 2, "b": 2}, box_dots=True) + assert ({"a": 1} | right).to_dict() == {"a": 2, "b": 2} + assert ({"a": 1} + right).to_dict() == {"a": 2, "b": 2} + assert (right | {"a": 1}).to_dict() == {"a": 1, "b": 2} + + def test_left_operand_is_not_changed(self): + left = {"a": {"x": 1}} + result = left | Box(box_dots=True) + result["a.x"] = 2 + assert left == {"a": {"x": 1}} + + +class TestDefaultBoxAttrFactories: + def test_list_class_like_defaultdict(self): + b = Box(default_box=True, default_box_attr=list) + assert isinstance(b.tags, BoxList) and b.tags == [] + b.tags = b.tags + [1] + assert b.to_dict() == {"tags": [1]} + + def test_list_class_with_create_on_get(self): + b = Box(default_box=True, default_box_attr=list, default_box_create_on_get=True) + b.tags.append({"a": 1}) + assert b.to_dict() == {"tags": [{"a": 1}]} + assert type(b.tags[0]) is Box + + @pytest.mark.parametrize("factory, expected", [(int, 0), (str, ""), (set, set()), (lambda: "x", "x")]) + def test_other_factories(self, factory, expected): + assert Box(default_box=True, default_box_attr=factory).missing == expected + + def test_optional_parameters_are_left_alone(self): + def factory(key, prefix="item-"): + return prefix + key + + assert Box(default_box=True, default_box_attr=factory).thing == "item-thing" + + def test_positional_only_and_keyword_only(self): + def positional(key, box_instance, /): + return (key, type(box_instance).__name__) + + def keyword_only(*, box_instance, key): + return (key, type(box_instance).__name__) + + assert Box(default_box=True, default_box_attr=positional).a == ("a", "Box") + assert Box(default_box=True, default_box_attr=keyword_only).a == ("a", "Box") + + def test_required_unknown_parameter(self): + def factory(key, other): + return key + + with pytest.raises(BoxError, match="not 'other'"): + Box(default_box=True, default_box_attr=factory).a + + def test_class_with_key_parameter(self): + class Named: + def __init__(self, key): + self.key = key + + assert Box(default_box=True, default_box_attr=Named).thing.key == "thing" + + +class TestConfigBoxBool: + @pytest.mark.parametrize("value", ["off", "OFF", " Off ", "no", "false", "0", "n", "f", ""]) + def test_false_values(self, value): + assert ConfigBox(flag=value).bool("flag") is False + + @pytest.mark.parametrize("value", ["on", "yes", "true", "1", "y", "t", "anything"]) + def test_true_values(self, value): + assert ConfigBox(flag=value).bool("flag") is True From 344f600257e92d575638616db1c01dc6b7d00bcd Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Wed, 4 Nov 2026 08:57:29 -0500 Subject: [PATCH 60/61] Add comments on Box keys and BoxList items, kept through YAML (#184) Comments live outside the data, in a per container store ({key: {"before": [lines], "eol": text}} plus document start / end), so to_dict, to_json, equality and hashing never see them. * from_yaml with ruamel's round trip loader extracts them (box.comments re-assigns ruamel's "comment above a key" tokens, which it parses onto the previous key), to_yaml rebuilds CommentedMap / CommentedSeq objects and writes them back. Without comments, or with PyYAML / the safe dumper, the output is exactly as before. * get_comment / set_comment / del_comment on Box and BoxList, positions "eol" / "before", key None for the document ("start" / "end"), box_dots paths, negative list indexes, frozen boxes refuse changes. * Kept in sync: deletes, pop, popitem, clear drop them; ConfigBox latest write wins keeps the comment on the new spelling; camel_killer keys; BoxList insert / pop / remove / del / reverse / sort move them with their items (slice writes drop them); copy, deepcopy, pickle and Box(other_box) carry them. Co-Authored-By: Claude Opus 5.5 --- CHANGES.rst | 2 + box/box.py | 108 +++++++++++- box/box.pyi | 3 + box/box_list.py | 168 ++++++++++++++++-- box/box_list.pyi | 3 + box/comments.py | 333 +++++++++++++++++++++++++++++++++++ box/config_box.py | 7 + box/converters.py | 25 ++- box/converters.pyi | 6 + test/test_comments.py | 398 ++++++++++++++++++++++++++++++++++++++++++ 10 files changed, 1032 insertions(+), 21 deletions(-) create mode 100644 box/comments.py create mode 100644 test/test_comments.py diff --git a/CHANGES.rst b/CHANGES.rst index d3ead4d..ec5cad6 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -15,6 +15,7 @@ Breaking changes * to_yaml writes keys in insertion order with PyYAML and the ruamel safe / unsafe dumpers too (the default ruamel round trip dumper already did), pass sort_keys=True to sort them (#104, thanks to philipsd6 for reporting) * Box options are no longer named parameters of Box.__new__ / Box.__init__, they are read from keyword arguments (behavior is the same, the type stubs still list them) * DDBox options can now be overridden, e.g. DDBox(default_box=False) +* to_yaml now writes the comments of YAML loaded with ruamel.yaml's default round trip loader (#184), and get_comment, set_comment and del_comment are new protected key names * Build and development tooling changed (see below): installing from an sdist now needs setuptools>=77, and building the Cython version from source requires --no-build-isolation Changes @@ -22,6 +23,7 @@ Changes * Fixing #274 default_box_create_on_get=False not creating missing parent keys on assignment, e.g. box.a.b = 1 (thanks to gyanu2507 for the fix and wrdls for reporting) * Adding #263 "merge" option for box_merge_lists to merge lists of dictionaries element by element (thanks to ChrisJr404) * Adding #314 case-insensitive ConfigBox keys for [] access, in, del, update, merge_update and box_dots paths, matching configparser (thanks to binggao1230) +* Adding #184 comments on keys and list items: from_yaml keeps the comments of the document and to_yaml writes them back, and get_comment / set_comment / del_comment manage them on any Box or BoxList (thanks to philipsd6 for the request and michaelaye for the push) * Adding #296 _box_defaults class attribute so subclasses can change Box option defaults without overriding __init__ (also #223, #210, thanks to marcelloromani, 12rambau and miversen33 for reporting) * Adding #279 camel_killer_box_keep_keys to keep the original CamelCase keys and only add snake_case attribute aliases (thanks to jacobtomlinson for the suggestion) * Adding #123 box_dots path segments made of digits also match integer keys, e.g. box['servers.2'] for {'servers': {2: ...}} (thanks to richieadler for reporting) diff --git a/box/box.py b/box/box.py index 53fe5df..e1ce204 100644 --- a/box/box.py +++ b/box/box.py @@ -18,18 +18,18 @@ from typing import Any import box +from box import comments as _comments from box.converters import ( BOX_PARAMETERS, _from_json, _from_msgpack, _from_toml, _from_toon, - _from_yaml, + _from_yaml_with_comments, _to_json, _to_msgpack, _to_toml, _to_toon, - _to_yaml, msgpack_available, toml_read_library, toml_write_library, @@ -269,6 +269,9 @@ class Box(dict): "to_toon", "from_toon", "merge_update", + "get_comment", + "set_comment", + "del_comment", ] + [attr for attr in dir({}) if not attr.startswith("_")] def __init_subclass__(cls, **kwargs): @@ -320,6 +323,8 @@ def __init__(self, *args: Any, **kwargs: Any): self.__setitem__(k, v) else: raise BoxValueError("First argument must be mapping or iterable") + if isinstance(args[0], Box): + args[0]._comment_copy_to(self) elif args: raise BoxTypeError(f"Box expected at most 1 argument, got {len(args)}") @@ -501,7 +506,8 @@ def get(self, key, default=NO_DEFAULT): return self[key] def __copy_internals(self, new, deep=False, memo=None): - """Carry instance-only attributes listed in `_box_internal_attrs` over to `new`.""" + """Carry instance-only attributes listed in `_box_internal_attrs`, and comments, over to `new`.""" + self._comment_copy_to(new) for name in self._box_internal_attrs: if name in self.__dict__: value = self.__dict__[name] @@ -776,6 +782,82 @@ def _flush_pending_parent(self): parent._box_config["__safe_keys"][parent._safe_attr(key)] = key dict.__setitem__(parent, key, self) + def _comment_store(self, create: bool = True) -> Any: + store = self._box_config.get("__comments") + if store is None and create: + store = self._box_config["__comments"] = {} + return store + + def _comment_document(self, create: bool = True) -> Any: + document = self._box_config.get("__comments_document") + if document is None and create: + document = self._box_config["__comments_document"] = {} + return document + + def _comment_check_frozen(self): + if self._box_config["frozen_box"] and self._box_config["__created"]: + raise BoxError("Box is frozen") + + def _comment_resolve(self, key): + """The stored key a key from YAML or the comment API refers to (camel_killer renames keys).""" + if dict.__contains__(self, key): + return key + if isinstance(key, str) and self.__camel_destructive(): + converted = _camel_killer(key) + if dict.__contains__(self, converted): + return converted + return key + + def _comment_owner(self, key): + """(container, key) that holds the comment for `key`, following box_dots paths.""" + if key is None: + return self, None + resolved = self._comment_resolve(key) + if dict.__contains__(self, resolved): + return self, resolved + if self.__process_dotted_key(key): + first, children = _parse_box_dots(self, key) + first = self._comment_resolve(self.__dots_int_key(first)) + if dict.__contains__(self, first): + child = dict.__getitem__(self, first) + if isinstance(child, Box): + return child._comment_owner(child.__dots_int_key(children)) + if isinstance(child, box.BoxList): + return child._comment_owner(children) + raise BoxKeyError(f"{key!r} is not in the Box, comments can only be attached to existing keys") + + def _comment_copy_to(self, other): + store = self._box_config.get("__comments") + if store: + other._comment_store().update( + {k: copy.deepcopy(v) for k, v in store.items() if dict.__contains__(other, k)} + ) + document = self._box_config.get("__comments_document") + if document: + other._comment_document().update(copy.deepcopy(document)) + + # ---- Comments (#184): kept outside the data, written by to_yaml with ruamel.yaml ---- + + def get_comment(self, key: Any = None) -> dict | None: + """ + Return the comments of `key` as ``{"before": text, "eol": text}`` (a position without a comment + is left out), or None. ``key=None`` returns the document comments ``{"start": ..., "end": ...}``. + With box_dots, `key` can be a dotted path. + """ + return _comments.get_comment(self, key) + + def set_comment(self, key: Any, text: Any, position: str | None = None) -> None: + """ + Attach a comment to an existing key. `position` is "eol" (default, on the key's line) or + "before" (lines above the key, may contain newlines). ``key=None`` sets a document comment, + position "start" (default) or "end". An empty `text` removes the comment at that position. + """ + _comments.set_comment(self, key, text, position) + + def del_comment(self, key: Any = None) -> None: + """Remove every comment of `key` (``None``: the document comments).""" + _comments.del_comment(self, key) + def __getstate__(self): # Ephemeral-child bookkeeping (a reference to the parent) must never be pickled state = self.__dict__.copy() @@ -856,6 +938,9 @@ def __delitem__(self, key): super().__delitem__(key) except KeyError as err: raise BoxKeyError(str(err)) from _exception_cause(err) + store = self._box_config.get("__comments") + if store: + store.pop(key, None) if self._box_config["conversion_box"]: safe_key = self._safe_attr(key) safe_keys = self._box_config["__safe_keys"] @@ -921,6 +1006,7 @@ def clear(self): raise BoxError("Box is frozen") super().clear() self._box_config["__safe_keys"].clear() + self._box_config.pop("__comments", None) def popitem(self): if self._box_config["frozen_box"]: @@ -1232,7 +1318,8 @@ def to_yaml( :param yaml_kwargs: additional arguments to pass to yaml.dump :return: string of YAML (if no filename provided) """ - return _to_yaml( + return _comments.dump_yaml( + self, self.to_dict(), filename=filename, default_flow_style=default_flow_style, @@ -1266,12 +1353,17 @@ def from_yaml( if arg in BOX_PARAMETERS: box_args[arg] = kwargs.pop(arg) - data = _from_yaml(yaml_string=yaml_string, filename=filename, encoding=encoding, errors=errors, **kwargs) + data, comments = _from_yaml_with_comments( + yaml_string=yaml_string, filename=filename, encoding=encoding, errors=errors, **kwargs + ) if not data: - return cls(**box_args) - if not isinstance(data, dict): + result = cls(**box_args) + elif not isinstance(data, dict): raise BoxError(f"yaml data not returned as a dictionary but rather a {type(data).__name__}") - return cls(data, **box_args) + else: + result = cls(data, **box_args) + _comments.apply_comments(result, comments) + return result else: diff --git a/box/box.pyi b/box/box.pyi index f5ec6da..b9d2a2a 100644 --- a/box/box.pyi +++ b/box/box.pyi @@ -80,6 +80,9 @@ class Box(dict): def __reversed__(self) -> Generator: ... def to_dict(self) -> dict: ... def update(self, *args, **kwargs) -> None: ... + def get_comment(self, key: Any = ...) -> dict[str, str] | None: ... + def set_comment(self, key: Any, text: str | None, position: str | None = ...) -> None: ... + def del_comment(self, key: Any = ...) -> None: ... def merge_update(self, *args, **kwargs) -> None: ... def setdefault(self, item, default: Incomplete | None = ...): ... def to_json(self, filename: str | PathLike | None = ..., encoding: str = ..., errors: str = ..., **json_kwargs): ... diff --git a/box/box_list.py b/box/box_list.py index d6e2394..883e5c9 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -12,6 +12,7 @@ from typing import Any import box +from box import comments as _comments from box.converters import ( BOX_PARAMETERS, _from_csv, @@ -19,21 +20,21 @@ _from_msgpack, _from_toml, _from_toon, - _from_yaml, + _from_yaml_with_comments, _to_csv, _to_json, _to_msgpack, _to_toml, _to_toon, - _to_yaml, msgpack_available, toml_read_library, toon_available, yaml_available, ) -from box.exceptions import BoxError, BoxTypeError +from box.exceptions import BoxError, BoxKeyError, BoxTypeError _list_pos_re = re.compile(r"\[(\d+)\]") +_comment_index_re = re.compile(r"\[(-?\d+)\]") # the comment API also takes negative indexes def _frozen_box_list_method(*args, **kwargs): @@ -62,6 +63,8 @@ def __init__(self, iterable: Iterable | None = None, box_class: type[box.Box] = if iterable is not None: for x in iterable: self.append(x) + if isinstance(iterable, BoxList) and iterable is not self: + iterable._comment_copy_to(self) self.box_org_ref = None if box_options.get("frozen_box"): for method in ["append", "clear", "extend", "insert", "pop", "remove", "reverse", "sort"]: @@ -101,7 +104,9 @@ def __delitem__(self, key): return super().__delitem__(pos) if hasattr(self[pos], "__delitem__"): return self[pos].__delitem__(key[len(list_pos.group()) :].lstrip(".")) # type: ignore + length = len(self) super().__delitem__(key) + self._comment_after_delete(key, length) def __setitem__(self, key, value): if self.box_options.get("frozen_box"): @@ -122,7 +127,7 @@ def __setitem__(self, key, value): # existing element (e.g. ``a[0].y`` after ``a[0].x``) would discard the # data already stored there. Mirrors the guard in Box.__setitem__. current = super().__getitem__(pos) - if children[0] == "[": + if children.startswith("["): if not isinstance(current, box.BoxList): super().__setitem__(pos, box.BoxList(**self.box_options)) elif not isinstance(current, box.Box): @@ -135,7 +140,9 @@ def converted_items(): yield self._convert(item) # Let list validate the slice before consuming replacement values. - return super().__setitem__(key, converted_items()) + super().__setitem__(key, converted_items()) + self.__dict__.pop("_box_comments", None) # items moved, their comments can't follow + return super().__setitem__(key, self._convert(value)) def __iadd__(self, value): # type: ignore[misc] # list accepts any iterable for +=, not only lists @@ -178,7 +185,128 @@ def extend(self, iterable): self.append(item) def insert(self, index, p_object): + length = len(self) super().insert(index, self._convert(p_object)) + if self.__dict__.get("_box_comments"): + at = min(max(index + length, 0) if index < 0 else index, length) + self._comment_reindex(lambda k: k + 1 if k >= at else k) + + def pop(self, index=-1): + length = len(self) + value = super().pop(index) + self._comment_after_delete(index, length) + return value + + def remove(self, value): + self.pop(self.index(value)) + + def clear(self): + super().clear() + self.__dict__.pop("_box_comments", None) + + def reverse(self): + super().reverse() + last = len(self) - 1 + self._comment_reindex(lambda k: last - k) + + def sort(self, *, key=None, reverse=False): + if not self.__dict__.get("_box_comments"): + return super().sort(key=key, reverse=reverse) + # Work out where every item goes (same stable order as list.sort) so comments follow them + sort_key = key or (lambda x: x) + order = sorted(range(len(self)), key=lambda i: sort_key(list.__getitem__(self, i)), reverse=reverse) + new_position = {old: new for new, old in enumerate(order)} + super().sort(key=key, reverse=reverse) + self._comment_reindex(new_position.get) + + # ---- Comments (#184), by item index ---- + + def _comment_store(self, create: bool = True) -> Any: + store = self.__dict__.get("_box_comments") + if store is None and create: + store = self.__dict__["_box_comments"] = {} + return store + + def _comment_document(self, create: bool = True) -> Any: + document = self.__dict__.get("_box_comments_document") + if document is None and create: + document = self.__dict__["_box_comments_document"] = {} + return document + + def _comment_check_frozen(self): + if self.box_options.get("frozen_box"): + raise BoxError("BoxList is frozen") + + def _comment_reindex(self, mapping): + store = self.__dict__.get("_box_comments") + if store: + moved = {} + for index, comment in store.items(): + new_index = mapping(index) + if new_index is not None: + moved[new_index] = comment + self.__dict__["_box_comments"] = moved + + def _comment_after_delete(self, key, length): + if not self.__dict__.get("_box_comments"): + return + if isinstance(key, slice): + self.__dict__.pop("_box_comments", None) + return + gone = key + length if key < 0 else key + self._comment_reindex(lambda k: None if k == gone else (k - 1 if k > gone else k)) + + def _comment_owner(self, key): + """(container, index) that holds the comment for `key`, following box_dots paths.""" + if key is None: + return self, None + if isinstance(key, int) and not isinstance(key, bool): + index = key + len(self) if key < 0 else key + if 0 <= index < len(self): + return self, index + elif isinstance(key, str) and key.startswith("["): + list_pos = _comment_index_re.match(key) + if list_pos is not None: + index = int(list_pos.groups()[0]) + index = index + len(self) if index < 0 else index + rest = key[len(list_pos.group()) :].lstrip(".") + if 0 <= index < len(self): + if not rest: + return self, index + child = list.__getitem__(self, index) + if hasattr(child, "_comment_owner"): + return child._comment_owner(rest) + raise BoxKeyError(f"{key!r} is not in the BoxList, comments can only be attached to existing items") + + def _comment_copy_to(self, other): + store = self.__dict__.get("_box_comments") + if store: + other._comment_store().update({k: copy.deepcopy(v) for k, v in store.items() if k < len(other)}) + document = self.__dict__.get("_box_comments_document") + if document: + other._comment_document().update(copy.deepcopy(document)) + + # ---- Comments (#184): kept outside the data, written by to_yaml with ruamel.yaml ---- + + def get_comment(self, key: Any = None) -> dict | None: + """ + Return the comments of `key` as ``{"before": text, "eol": text}`` (a position without a comment + is left out), or None. ``key=None`` returns the document comments ``{"start": ..., "end": ...}``. + With box_dots, `key` can be a dotted path. + """ + return _comments.get_comment(self, key) + + def set_comment(self, key: Any, text: Any, position: str | None = None) -> None: + """ + Attach a comment to an existing key. `position` is "eol" (default, on the key's line) or + "before" (lines above the key, may contain newlines). ``key=None`` sets a document comment, + position "start" (default) or "end". An empty `text` removes the comment at that position. + """ + _comments.set_comment(self, key, text, position) + + def del_comment(self, key: Any = None) -> None: + """Remove every comment of `key` (``None``: the document comments).""" + _comments.del_comment(self, key) def _dotted_helper(self) -> list[str]: keys = [] @@ -203,7 +331,9 @@ def __str__(self): return str(self.to_list()) def __copy__(self): - return self.__class__((x for x in self), **self.box_options) + out = self.__class__((x for x in self), **self.box_options) + self._comment_copy_to(out) + return out def __deepcopy__(self, memo=None): out = self.__class__(**{**self.box_options, "frozen_box": False}) @@ -212,6 +342,7 @@ def __deepcopy__(self, memo=None): items = [copy.deepcopy(k, memo=memo) for k in self] # Filling through __init__ applies the options (frozen included) to the copied items out.__init__(items, **self.box_options) + self._comment_copy_to(out) return out def __reduce_ex__(self, protocol): @@ -219,7 +350,11 @@ def __reduce_ex__(self, protocol): # re-created every item with default options. Keep the items in the state instead, # so __setstate__ restores the options first. Self references still work because # pickle memoizes the new list before the state is saved. - return copyreg.__newobj__, (self.__class__,), {"box_options": self.box_options, "items": list(self)} + state = {"box_options": self.box_options, "items": list(self)} + for name in ("_box_comments", "_box_comments_document"): + if self.__dict__.get(name): + state[name] = self.__dict__[name] + return copyreg.__newobj__, (self.__class__,), state def __setstate__(self, state): if "items" not in state: @@ -227,6 +362,9 @@ def __setstate__(self, state): self.__dict__.update(state) return self.__init__(state["items"], **state["box_options"]) + for name in ("_box_comments", "_box_comments_document"): + if name in state: + self.__dict__[name] = state[name] def __hash__(self) -> int: # type: ignore[override] if self.box_options.get("frozen_box"): @@ -335,7 +473,8 @@ def to_yaml( :param yaml_kwargs: additional arguments to pass to yaml.dump :return: string of YAML or return of `yaml.dump` """ - return _to_yaml( + return _comments.dump_yaml( + self, self.to_list(), filename=filename, default_flow_style=default_flow_style, @@ -369,12 +508,17 @@ def from_yaml( if arg in BOX_PARAMETERS: box_args[arg] = kwargs.pop(arg) - data = _from_yaml(yaml_string=yaml_string, filename=filename, encoding=encoding, errors=errors, **kwargs) + data, comments = _from_yaml_with_comments( + yaml_string=yaml_string, filename=filename, encoding=encoding, errors=errors, **kwargs + ) if not data: - return cls(**box_args) - if not isinstance(data, list): + result = cls(**box_args) + elif not isinstance(data, list): raise BoxError(f"yaml data not returned as a list but rather a {type(data).__name__}") - return cls(data, **box_args) + else: + result = cls(data, **box_args) + _comments.apply_comments(result, comments) + return result else: diff --git a/box/box_list.pyi b/box/box_list.pyi index c7f2470..ff97496 100644 --- a/box/box_list.pyi +++ b/box/box_list.pyi @@ -33,6 +33,9 @@ class BoxList(list): def __copy__(self) -> BoxList: ... def __deepcopy__(self, memo: Any | None = ...) -> BoxList: ... def __hash__(self) -> int: ... # type: ignore[override] + def get_comment(self, key: Any = ...) -> dict[str, str] | None: ... + def set_comment(self, key: Any, text: str | None, position: str | None = ...) -> None: ... + def del_comment(self, key: Any = ...) -> None: ... def to_list(self) -> list: ... def _dotted_helper(self) -> list[str]: ... def to_json( diff --git a/box/comments.py b/box/comments.py new file mode 100644 index 0000000..069f268 --- /dev/null +++ b/box/comments.py @@ -0,0 +1,333 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Comments attached to Box keys and BoxList items (#184). + +Every Box and BoxList keeps the comments for its own keys or indexes, outside the data, in a +store of ``{key: {"before": [lines], "eol": str | None}}``. The outermost container can also hold +document comments, ``{"start": [lines], "end": [lines]}``. + +YAML loaded with the ruamel.yaml round trip loader fills the stores, ``to_yaml`` writes them +back. ruamel attaches a comment line above a key to the previous key's token while parsing, so +``extract_comments`` walks the document in order and hands those trailing lines to the next key. +""" + +from __future__ import annotations + +from typing import Any + +from box.converters import _ruamel_to_builtin +from box.exceptions import BoxValueError + +__all__ = [ + "extract_comments", + "apply_comments", + "has_comments", + "commented_tree", + "dump_yaml", + "get_comment", + "set_comment", + "del_comment", +] + +POSITIONS = ("before", "eol") +DOCUMENT_POSITIONS = ("start", "end") + + +def _token_lines(value: str) -> list[str]: + """Comment token text to comment lines without the "#", blank lines kept as "".""" + out = [] + for line in value.split("\n"): + line = line.strip() + out.append(line[1:].lstrip() if line.startswith("#") else line) + return out + + +def _text_to_lines(text: str) -> list[str]: + return [line[1:].lstrip() if line.strip().startswith("#") else line for line in text.split("\n")] + + +def normalize(position: Any, text: Any, document: bool = False) -> Any: + """Validate a comment set through the API and turn it into its stored form.""" + allowed = DOCUMENT_POSITIONS if document else POSITIONS + if position not in allowed: + raise BoxValueError(f"position must be one of {', '.join(repr(p) for p in allowed)}, not {position!r}") + if text is None or text == "": + return None + if not isinstance(text, str): + raise BoxValueError(f"comment must be a string, not {type(text).__name__}") + if position == "eol": + if "\n" in text: + raise BoxValueError("an end of line comment must be a single line") + return _text_to_lines(text)[0] + return _text_to_lines(text) + + +def public(entry: dict | None) -> dict | None: + """Stored comment entry to what get_comment returns: strings, missing positions as None.""" + if not entry: + return None + return {k: ("\n".join(v) if isinstance(v, list) else v) for k, v in entry.items()} + + +def get_comment(obj, key) -> dict | None: + owner, key = obj._comment_owner(key) + if key is None: + return public(owner._comment_document(create=False)) + store = owner._comment_store(create=False) + return public(store.get(key)) if store else None + + +def set_comment(obj, key, text, position=None) -> None: + owner, key = obj._comment_owner(key) + owner._comment_check_frozen() + document = key is None + position = position or ("start" if document else "eol") + value = normalize(position, text, document=document) + if document: + entry = owner._comment_document() + else: + store = owner._comment_store() + entry = store.setdefault(key, {}) + if value is None: + entry.pop(position, None) + else: + entry[position] = value + if not document and not entry: + del store[key] + + +def del_comment(obj, key) -> None: + owner, key = obj._comment_owner(key) + owner._comment_check_frozen() + if key is None: + owner._comment_document().clear() + else: + store = owner._comment_store(create=False) + if store: + store.pop(key, None) + + +def extract_comments(root: Any) -> dict | None: + """ + Collect the comments of a document loaded with the ruamel.yaml round trip loader. + + :return: ``{"start": lines, "end": lines, "keys": {path: {"before": lines, "eol": text}}}``, + or None when the data carries no comments (other loaders, or a document without any). + """ + try: + from ruamel.yaml.comments import CommentedMap, CommentedSeq + except ImportError: # pragma: no cover (depends on installed packages) + return None + if not isinstance(root, (CommentedMap, CommentedSeq)): + return None + + model: dict = {"start": None, "end": None, "keys": {}} + seen: set[int] = set() + pending: list[str] = [] + + def entry(path): + return model["keys"].setdefault(path, {"before": [], "eol": None}) + + def take_lines(tokens): + for token in tokens or []: + if token is not None and id(token) not in seen: + seen.add(id(token)) + pending.extend(_token_lines(token.value)[:-1]) + + def handle(token, path): + if token is None or id(token) in seen: + return + seen.add(id(token)) + value = token.value + if value.startswith("\n"): + rest = value[1:] + else: + # The first line is the end of line comment, the following lines belong to the next key + first, _, rest = value.partition("\n") + entry(path)["eol"] = first.strip()[1:].strip() + if rest: + pending.extend(_token_lines(rest)[:-1]) # comment tokens end with a newline + + root_comment = getattr(root.ca, "comment", None) + if root_comment and len(root_comment) > 1 and root_comment[1]: + model["start"] = [line for token in root_comment[1] for line in _token_lines(token.value)[:-1]] + seen.update(id(token) for token in root_comment[1]) + + def walk(node, path): + if isinstance(node, CommentedMap): + items = node.items() + is_map = True + elif isinstance(node, CommentedSeq): + items = enumerate(node) + is_map = False + else: + return + node_comment = getattr(node.ca, "comment", None) + if path and node_comment and len(node_comment) > 1: + take_lines(node_comment[1]) + for key, value in items: + item_path = path + (_ruamel_to_builtin(key),) + if pending: + entry(item_path)["before"].extend(pending) + pending.clear() + tokens = node.ca.items.get(key) + if tokens: + if is_map: + handle(tokens[2], item_path) + take_lines(tokens[3]) # comment lines between "key:" and its nested value + else: + handle(tokens[0], item_path) + walk(value, item_path) + + walk(root, ()) + if pending: + model["end"] = list(pending) + if not model["start"] and not model["end"] and not model["keys"]: + return None + return model + + +def _resolve_key(container, key): + """The key in `container` the YAML key ended up as, or a sentinel when it isn't there.""" + if isinstance(container, list): + return key if isinstance(key, int) and 0 <= key < len(container) else _MISSING + if dict.__contains__(container, key): + return key + found = container._comment_resolve(key) # only Box / BoxList containers get here + return found if dict.__contains__(container, found) else _MISSING + + +_MISSING = object() + + +def apply_comments(root, model: dict | None) -> None: + """Store the comments of an extracted model on the Box / BoxList tree built from the same document.""" + if not model: + return + for position in DOCUMENT_POSITIONS: + if model.get(position): + root._comment_document()[position] = list(model[position]) + for path, comment in model["keys"].items(): + node = root + for segment in path[:-1]: + found = _resolve_key(node, segment) + if found is _MISSING: + node = None + break + node = list.__getitem__(node, found) if isinstance(node, list) else dict.__getitem__(node, found) + if not hasattr(node, "_comment_store"): + node = None + break + if node is None: + continue # the key moved or disappeared when the Box was built (box_dots, camel_killer, ...) + key = _resolve_key(node, path[-1]) + if key is _MISSING: + continue + stored = {} + if comment["before"]: + stored["before"] = list(comment["before"]) + if comment["eol"]: + stored["eol"] = comment["eol"] + if stored: + node._comment_store()[key] = stored + + +def has_comments(obj, _seen=None) -> bool: + """True when any Box / BoxList in the tree has a key, item or document comment.""" + store = getattr(obj, "_comment_store", None) + if store is None: + return False + if obj._comment_store(create=False) or obj._comment_document(create=False): + return True + seen = _seen if _seen is not None else set() + if id(obj) in seen: + return False + seen.add(id(obj)) + values = obj.values() if isinstance(obj, dict) else obj + return any(has_comments(value, seen) for value in values) + + +def _add_eol_comment(out, key, text): + """End of line comment two spaces after the value, wherever it is (ruamel otherwise aligns it + with a neighbouring comment, or uses one space when there is none).""" + try: + from ruamel.yaml.error import CommentMark + from ruamel.yaml.tokens import CommentToken + + out._yaml_add_eol_comment([CommentToken(f" # {text}", CommentMark(0)), None], key=key) + except (ImportError, AttributeError, TypeError): # pragma: no cover (other ruamel versions) + out.yaml_add_eol_comment(text, key) + + +def _set_ruamel_comment(out, key, comment, indent): + # ruamel quirk: on a CommentedSeq the end of line comment must be set before the before comment + if comment.get("eol"): + _add_eol_comment(out, key, comment["eol"]) + if comment.get("before"): + out.yaml_set_comment_before_after_key(key, before="\n".join(comment["before"]), indent=indent) + + +def commented_tree(obj, plain, column=0, _seen=None): + """ + Turn `plain` (the to_dict / to_list output of `obj`) into ruamel CommentedMap / CommentedSeq + objects carrying the comments stored on `obj` and its nested boxes. + + `column` is where this container's keys (or list dashes) start with ruamel's default layout: + nested mappings are indented by 2, sequences start at their parent key's column. + """ + from ruamel.yaml.comments import CommentedMap, CommentedSeq + + seen = _seen if _seen is not None else set() + if isinstance(plain, (dict, list)): + if id(plain) in seen: + return plain # self references are written as they are + seen = seen | {id(plain)} + if isinstance(plain, dict): + out = CommentedMap() + for key, value in plain.items(): + child = dict.get(obj, key) if isinstance(obj, dict) else None + out[key] = commented_tree(child, value, column if isinstance(value, list) else column + 2, seen) + keys = list(out) + elif isinstance(plain, list): + out = CommentedSeq() + for index, value in enumerate(plain): + child = list.__getitem__(obj, index) if isinstance(obj, list) and index < len(obj) else None + out.append(commented_tree(child, value, column + 2, seen)) + keys = list(range(len(out))) + else: + return plain + store = obj._comment_store(create=False) if hasattr(obj, "_comment_store") else None + if store: + for key in keys: + if key in store: + _set_ruamel_comment(out, key, store[key], column) + return out + + +def _document_lines(obj, position) -> str: + document = obj._comment_document(create=False) if hasattr(obj, "_comment_document") else None + if not document or not document.get(position): + return "" + return "".join((f"# {line}" if line else "") + "\n" for line in document[position]) + + +def dump_yaml(obj, plain, filename=None, encoding: str = "utf-8", errors: str = "strict", **yaml_kwargs): + """ + to_yaml for Box and BoxList: with comments and the ruamel round trip dumper, write them out, + otherwise dump `plain` exactly as before. + """ + from box import converters + + use_comments = converters.ruamel_available and yaml_kwargs.get("ruamel_typ", "rt") == "rt" and has_comments(obj) + if not use_comments: + return converters._to_yaml(plain, filename=filename, encoding=encoding, errors=errors, **yaml_kwargs) + body = converters._to_yaml(commented_tree(obj, plain), encoding=encoding, errors=errors, **yaml_kwargs) + # Document comments are written as text: ruamel drops a blank line after a start comment + text = _document_lines(obj, "start") + body + _document_lines(obj, "end") + if not filename: + return text + converters._exists(filename, create=True) + with open(filename, "w", encoding=encoding, errors=errors) as f: + f.write(text) + return None diff --git a/box/config_box.py b/box/config_box.py index 2bc8004..5d5ed87 100644 --- a/box/config_box.py +++ b/box/config_box.py @@ -120,6 +120,9 @@ def _ci_take_over(self, key, keep_value=False): if existing is None or existing == key: return self._ci_check_frozen() + comments = self._box_config.get("__comments") + if comments and existing in comments: + comments[key] = comments.pop(existing) # the comment stays with the key under its new spelling value = dict.__getitem__(self, existing) len_before = dict.__len__(self) dict.__delitem__(self, existing) @@ -136,6 +139,10 @@ def _ci_take_over(self, key, keep_value=False): dict.__setitem__(self, key, value) self._ci_after_write(key, len_before, False) + def _comment_resolve(self, key): + found = self._ci_key(key) + return found if found is not None else super()._comment_resolve(key) + def __getitem__(self, item, _ignore_default=False): return super().__getitem__(self._ci_resolve(item), _ignore_default=_ignore_default) diff --git a/box/converters.py b/box/converters.py index 7c144fb..335196f 100644 --- a/box/converters.py +++ b/box/converters.py @@ -255,6 +255,29 @@ def _from_yaml( ruamel_attrs: dict | None = None, **kwargs, ): + return _ruamel_to_builtin( + _load_yaml(yaml_string, filename, encoding, errors, ruamel_typ=ruamel_typ, ruamel_attrs=ruamel_attrs, **kwargs) + ) + + +def _from_yaml_with_comments(*args, **kwargs): + """Like _from_yaml, also returning the comments found in the document (see box.comments).""" + from box.comments import extract_comments + + raw = _load_yaml(*args, **kwargs) + return _ruamel_to_builtin(raw), extract_comments(raw) + + +def _load_yaml( + yaml_string: str | None = None, + filename: str | PathLike | None = None, + encoding: str = "utf-8", + errors: str = "strict", + ruamel_typ: str = "rt", + ruamel_attrs: dict | None = None, + **kwargs, +): + """Load YAML as the parser returns it (ruamel round trip types included).""" if not ruamel_attrs: ruamel_attrs = {} if filename: @@ -285,7 +308,7 @@ def _from_yaml( raise BoxError(MISSING_PARSER_ERROR) else: raise BoxError("from_yaml requires a string or filename") - return _ruamel_to_builtin(data) + return data def _to_toml(obj, filename: str | PathLike | None = None, encoding: str = "utf-8", errors: str = "strict"): diff --git a/box/converters.pyi b/box/converters.pyi index 4c0c70b..933dbc3 100644 --- a/box/converters.pyi +++ b/box/converters.pyi @@ -3,6 +3,8 @@ from os import PathLike from typing import Any yaml_available: bool +ruamel_available: bool +pyyaml_available: bool toml_available: bool msgpack_available: bool toon_available: bool @@ -11,6 +13,10 @@ toml_read_library: Any | None toml_write_library: Any | None toml_decode_error: Callable | None +def _exists(filename: str | PathLike, create: bool = ...) -> Any: ... +def _ruamel_to_builtin(obj: Any) -> Any: ... +def _load_yaml(*args: Any, **kwargs: Any) -> Any: ... +def _from_yaml_with_comments(*args: Any, **kwargs: Any) -> tuple[Any, dict | None]: ... def _to_json(obj, filename: str | PathLike | None = ..., encoding: str = ..., errors: str = ..., **json_kwargs): ... def _from_json( json_string: str | None = ..., diff --git a/test/test_comments.py b/test/test_comments.py new file mode 100644 index 0000000..fa7e1b8 --- /dev/null +++ b/test/test_comments.py @@ -0,0 +1,398 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Comments on Box keys and BoxList items, read from and written to YAML (#184).""" + +import copy +import json +import pickle + +import pytest + +import box.converters as converters +from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox +from box.exceptions import BoxValueError + +pytestmark = pytest.mark.skipif(not converters.ruamel_available, reason="comments need ruamel.yaml") + +DOCUMENT = """\ +# Service settings +# second line + +name: box # the name +# Where to listen +server: + host: localhost # bind address + + port: 8080 +# Things +items: +# first +- a # eol a +- b +last: 1 +# end of the document +""" + + +class TestReadAndWrite: + def test_round_trip_is_unchanged(self): + assert Box.from_yaml(DOCUMENT).to_yaml() == DOCUMENT + + def test_comments_are_read(self): + bx = Box.from_yaml(DOCUMENT) + assert bx.get_comment(None) == {"start": "Service settings\nsecond line\n", "end": "end of the document"} + assert bx.get_comment("name") == {"eol": "the name"} + assert bx.get_comment("server") == {"before": "Where to listen"} + assert bx.server.get_comment("host") == {"eol": "bind address"} + assert bx.server.get_comment("port") == {"before": ""} # the blank line + assert bx["items"].get_comment(0) == {"before": "first", "eol": "eol a"} + assert bx["items"].get_comment(1) is None + assert bx.get_comment("last") is None + + def test_data_is_unaffected(self): + bx = Box.from_yaml(DOCUMENT) + plain = {"name": "box", "server": {"host": "localhost", "port": 8080}, "items": ["a", "b"], "last": 1} + assert bx.to_dict() == plain + assert json.loads(bx.to_json()) == plain + assert bx == plain + assert Box.from_yaml(DOCUMENT) == Box(plain) + + def test_edits_keep_comments_on_their_keys(self): + bx = Box.from_yaml(DOCUMENT) + del bx.name + bx.server.port = 9090 + bx.server.timeout = 30 + bx.new = "x" + out = bx.to_yaml() + assert out.startswith("# Service settings\n# second line\n\n# Where to listen\nserver:\n") + assert " host: localhost # bind address\n\n port: 9090\n timeout: 30\n" in out + assert "the name" not in out + assert out.endswith("last: 1\nnew: x\n# end of the document\n") + + def test_comment_between_key_and_nested_value(self): + bx = Box.from_yaml("server:\n # inside\n host: x\n") + assert bx.server.get_comment("host") == {"before": "inside"} + assert bx.to_yaml() == "server:\n # inside\n host: x\n" + + def test_nested_list_of_maps(self): + src = "items:\n- a: 1 # one\n b: 2\n# second item\n- a: 3\n" + bx = Box.from_yaml(src) + assert bx["items"][0].get_comment("a") == {"eol": "one"} + assert bx["items"].get_comment(1) == {"before": "second item"} + assert bx.to_yaml() == src + + def test_document_without_comments_has_none(self): + bx = Box.from_yaml("a: 1\nb: [1, 2]\n") + assert bx.get_comment(None) is None + assert bx._box_config.get("__comments") is None + + def test_comment_only_document(self): + bx = Box.from_yaml("# nothing here\n") + assert bx == {} + + def test_numeric_keys(self): + bx = Box.from_yaml("1: one # first\n2.5: x\n") + assert bx.get_comment(1) == {"eol": "first"} + assert bx.to_yaml() == "1: one # first\n2.5: x\n" + + def test_files(self, tmp_path): + path = tmp_path / "config.yaml" + path.write_text(DOCUMENT) + bx = Box.from_yaml(filename=path) + bx.set_comment("last", "still last") + out = tmp_path / "out.yaml" + assert bx.to_yaml(filename=out) is None + assert out.read_text() == DOCUMENT.replace("last: 1\n", "last: 1 # still last\n") + + def test_box_list_documents(self): + src = "# people\n- name: a # first\n# then\n- name: b\n" + bl = BoxList.from_yaml(src) + assert bl.get_comment(None) == {"start": "people"} + assert bl[0].get_comment("name") == {"eol": "first"} + assert bl.get_comment(1) == {"before": "then"} + assert bl.to_yaml() == src + + +class TestApi: + def test_set_get_delete(self): + bx = Box(a=1, b={"c": 2}) + bx.set_comment("a", "eol text") + bx.set_comment("a", "line one\nline two", position="before") + bx.b.set_comment("c", "nested") + assert bx.get_comment("a") == {"eol": "eol text", "before": "line one\nline two"} + assert bx.to_yaml() == "# line one\n# line two\na: 1 # eol text\nb:\n c: 2 # nested\n" + bx.del_comment("a") + assert bx.get_comment("a") is None + bx.set_comment("b", "") # empty text removes that position + assert bx.get_comment("b") is None + + def test_remove_one_position(self): + bx = Box(a=1) + bx.set_comment("a", "x") + bx.set_comment("a", "y", position="before") + bx.set_comment("a", None) + assert bx.get_comment("a") == {"before": "y"} + + def test_hash_prefix_is_optional(self): + bx = Box(a=1) + bx.set_comment("a", "# already commented") + assert bx.get_comment("a") == {"eol": "already commented"} + + def test_document_comments(self): + bx = Box(a=1) + bx.set_comment(None, "header\n\nmore") + bx.set_comment(None, "footer", position="end") + assert bx.to_yaml() == "# header\n\n# more\na: 1\n# footer\n" + bx.del_comment() + assert bx.to_yaml() == "a: 1\n" + + @pytest.mark.parametrize( + "args, error", + [ + (("a", "two\nlines"), "single line"), + (("a", "x", "start"), "position must be one of 'before', 'eol'"), + ((None, "x", "eol"), "position must be one of 'start', 'end'"), + (("a", 5), "must be a string"), + ], + ) + def test_invalid(self, args, error): + with pytest.raises(BoxValueError, match=error): + Box(a=1).set_comment(*args) + + def test_missing_keys(self): + with pytest.raises(BoxKeyError, match="existing keys"): + Box().set_comment("missing", "x") + with pytest.raises(BoxKeyError): + Box().get_comment("missing") + with pytest.raises(BoxKeyError, match="existing items"): + BoxList([1]).set_comment(3, "x") + with pytest.raises(BoxKeyError): + Box(a={"b": 1}).set_comment("a.b", "x") # dotted paths need box_dots + + def test_box_dots_paths(self): + bx = Box({"a": {"b": 1}, "l": [{"x": 1}, 2]}, box_dots=True) + bx.set_comment("a.b", "deep") + bx.set_comment("l[0].x", "in a list") + bx.set_comment("l[1]", "item") + assert bx.a.get_comment("b") == {"eol": "deep"} + assert bx["l"][0].get_comment("x") == {"eol": "in a list"} + assert bx.get_comment("l[1]") == {"eol": "item"} + assert bx.get_comment("l[-1]") == {"eol": "item"} + + def test_box_dots_int_segments(self): + bx = Box({"a": {2: "two"}}, box_dots=True) + bx.set_comment("a.2", "int key") + assert bx.a.get_comment(2) == {"eol": "int key"} + + def test_negative_list_index(self): + bl = BoxList([1, 2, 3]) + bl.set_comment(-1, "last") + assert bl.get_comment(2) == {"eol": "last"} + + def test_methods_are_protected_names(self): + for name in ("get_comment", "set_comment", "del_comment"): + with pytest.raises(BoxKeyError, match="protected"): + setattr(Box(), name, 1) + + def test_frozen(self): + bx = Box.from_yaml("a: 1 # kept\n", frozen_box=True) + assert bx.get_comment("a") == {"eol": "kept"} + with pytest.raises(BoxError, match="frozen"): + bx.set_comment("a", "x") + with pytest.raises(BoxError, match="frozen"): + bx.del_comment("a") + bl = BoxList([1], frozen_box=True) + with pytest.raises(BoxError, match="frozen"): + bl.set_comment(0, "x") + + +class TestKeepingCommentsInSync: + def test_delete_pop_popitem_clear(self): + bx = Box(a=1, b=2, c=3, d=4) + for key in "abcd": + bx.set_comment(key, key) + del bx["a"] + bx.pop("b") + bx.popitem() + assert bx.get_comment("c") == {"eol": "c"} + bx["a"] = 1 + assert bx.get_comment("a") is None # a re-added key starts clean + bx.clear() + bx.c = 1 + assert bx.get_comment("c") is None + + def test_overwriting_a_value_keeps_the_comment(self): + bx = Box(a=1, b={"x": 1}) + bx.set_comment("a", "kept") + bx.set_comment("b", "kept too") + bx.a = 2 + bx.b = {"y": 2} + assert bx.get_comment("a") == {"eol": "kept"} + assert bx.get_comment("b") == {"eol": "kept too"} + + def test_merge_update_and_update_keep_existing(self): + bx = Box.from_yaml("a:\n b: 1 # keep\n") + bx.merge_update({"a": {"c": 2}}) + bx.update(z=1) + assert bx.a.get_comment("b") == {"eol": "keep"} + + def test_copy_deepcopy_pickle_and_rebuild(self): + bx = Box.from_yaml(DOCUMENT) + for other in (bx.copy(), copy.copy(bx), copy.deepcopy(bx), pickle.loads(pickle.dumps(bx)), Box(bx)): + assert other.to_yaml() == DOCUMENT + other = copy.deepcopy(bx) + other.server.set_comment("host", "changed") + assert bx.server.get_comment("host") == {"eol": "bind address"} + + def test_moving_a_subtree(self): + bx = Box.from_yaml(DOCUMENT) + target = Box() + target.settings = bx.server + assert target.settings.get_comment("host") == {"eol": "bind address"} + + def test_box_list_index_changes(self): + bl = BoxList(["a", "b", "c", "d"]) + for index in range(4): + bl.set_comment(index, "abcd"[index]) + + def comments(): + return [(bl.get_comment(i) or {}).get("eol") for i in range(len(bl))] + + bl.insert(1, "new") + assert comments() == ["a", None, "b", "c", "d"] + bl.pop(1) + assert comments() == ["a", "b", "c", "d"] + del bl[0] + assert comments() == ["b", "c", "d"] + bl.remove("c") + assert comments() == ["b", "d"] + bl.insert(-1, "x") + assert bl == ["b", "x", "d"] and comments() == ["b", None, "d"] + bl.reverse() + assert comments() == ["d", None, "b"] + bl.sort() + assert bl == ["b", "d", "x"] and comments() == ["b", "d", None] + bl.sort(key=lambda v: v == "b", reverse=True) + assert bl == ["b", "d", "x"] and comments() == ["b", "d", None] + bl.append("e") + bl += ["f"] + assert comments() == ["b", "d", None, None, None] + bl.pop() + bl[0:2] = ["y"] # slice writes drop the list's item comments + assert comments() == [None, None, None] + bl.set_comment(0, "again") + bl.clear() + bl.append(1) + assert bl.get_comment(0) is None + + def test_box_list_copies_and_pickles(self): + bl = BoxList.from_yaml("- 1 # one\n- 2\n") + for other in (copy.copy(bl), copy.deepcopy(bl), pickle.loads(pickle.dumps(bl)), BoxList(bl)): + assert other.get_comment(0) == {"eol": "one"} + + def test_config_box_any_case_and_latest_write(self): + cb = ConfigBox.from_yaml("Host: x # the host\n") + assert cb.get_comment("host") == {"eol": "the host"} + cb.set_comment("HOST", "renamed later") + cb["host"] = "y" # the latest spelling wins, the comment goes with it + assert cb.to_yaml() == "host: y # renamed later\n" + + def test_camel_killer_keys(self): + bx = Box.from_yaml("loadBalancer: x # lb\n", camel_killer_box=True) + assert bx.get_comment("load_balancer") == {"eol": "lb"} + assert bx.get_comment("loadBalancer") == {"eol": "lb"} + assert bx.to_yaml() == "load_balancer: x # lb\n" + + def test_box_dots_split_keys_lose_comments_safely(self): + bx = Box.from_yaml("a.b: 1 # dotted\n", box_dots=True, default_box=True) + assert bx.to_dict() == {"a": {"b": 1}} + assert bx.to_yaml() == "a:\n b: 1\n" + + +class TestOtherBackends: + def test_safe_dumper_ignores_comments(self): + bx = Box.from_yaml(DOCUMENT) + assert "#" not in bx.to_yaml(ruamel_typ="safe") + + def test_safe_loader_reads_none(self): + bx = Box.from_yaml(DOCUMENT, ruamel_typ="safe") + assert bx.get_comment(None) is None and bx.get_comment("name") is None + + def test_pyyaml(self, monkeypatch): + if not converters.pyyaml_available: + pytest.skip("PyYAML is not installed") + monkeypatch.setattr(converters, "ruamel_available", False) + bx = Box.from_yaml(DOCUMENT) + assert bx.get_comment("name") is None + bx.set_comment("name", "ignored by PyYAML") + assert "#" not in bx.to_yaml() + + def test_output_without_comments_is_unchanged(self): + data = {"z": 1, "a": {"b": [1, {"c": 2}]}} + assert Box(data).to_yaml() == converters._to_yaml(data) + assert BoxList([data]).to_yaml() == converters._to_yaml([data]) + + +class TestEdgeCases: + def test_missing_keys_and_paths(self): + with pytest.raises(BoxKeyError): + Box(camel_killer_box=True).set_comment("missingKey", "x") + dotted = Box({"a": 1, "l": [1]}, box_dots=True) + for key in ("nope.x", "a.x", "l[0].x", "l[5]", "l[x]", "l.x"): + with pytest.raises(BoxKeyError): + dotted.set_comment(key, "x") + with pytest.raises(BoxKeyError): + BoxList([1]).set_comment(1.5, "x") + + def test_delete_without_comments(self): + bx = Box(a=1) + bx.del_comment("a") + bl = BoxList([1]) + bl.del_comment(0) + bl.set_comment(0, "x") + bl.del_comment(0) + assert bl.get_comment(0) is None + + def test_box_list_document_and_positions(self): + bl = BoxList([1, 2]) + bl.set_comment(None, "top") + bl.set_comment(0, "above", position="before") + bl.set_comment(0, None, position="before") + assert bl.get_comment(0) is None + assert copy.copy(bl).get_comment(None) == {"start": "top"} + bl.del_comment() + assert bl.get_comment(None) is None + + def test_box_list_without_comments_keeps_working(self): + bl = BoxList([3, 1, 2]) + bl.sort() + bl.reverse() + del bl[0:1] + assert bl == [2, 1] + + def test_slice_delete_drops_item_comments(self): + bl = BoxList([1, 2, 3]) + bl.set_comment(2, "x") + del bl[0:1] + assert bl.get_comment(1) is None + + def test_empty_comment_and_missing_final_newline(self): + bx = Box.from_yaml("a: 1 #\nb: 2 # two\n# end") + assert bx.get_comment("a") is None + assert bx.get_comment("b") == {"eol": "two"} + assert bx.get_comment(None) == {"end": "end"} + + def test_frozen_lists_skip_item_comments(self): + bx = Box.from_yaml("l:\n- a: 1 # in a frozen list\n", frozen_box=True) + assert bx.to_dict() == {"l": ({"a": 1},)} # frozen boxes store lists as tuples + + def test_box_dots_split_parent_key(self): + bx = Box.from_yaml("a.b:\n c: 1 # c\n", box_dots=True, default_box=True) + assert bx.to_dict() == {"a": {"b": {"c": 1}}} + + def test_self_reference(self): + bx = Box(a=1) + dict.__setitem__(bx, "me", bx) # Box itself never builds cycles, guard against them anyway + assert bx.to_yaml() == "&id001\na: 1\nme: *id001\n" + bx.set_comment("a", "x") + assert "a: 1 # x" in bx.to_yaml() From 202c220946be3583d488703e596df29944b5c191 Mon Sep 17 00:00:00 2001 From: Chris Griffith Date: Wed, 4 Nov 2026 08:59:31 -0500 Subject: [PATCH 61/61] Comments: treat every YAML line break as a line break, reject control characters A comment containing \r, \x85, \u2028 or \u2029 was written with that character inside a "#" line, and YAML parsers read the rest of the line as document content, so set_comment("a", "x\rinjected: 1") added a key on reload. All YAML line breaks now split comment lines (end of line comments reject them) and other control characters are refused. Found by the automated security review. Co-Authored-By: Claude Opus 5.5 --- box/comments.py | 13 ++++++++++--- test/test_comments.py | 26 ++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 3 deletions(-) diff --git a/box/comments.py b/box/comments.py index 069f268..8f2cf63 100644 --- a/box/comments.py +++ b/box/comments.py @@ -14,6 +14,7 @@ from __future__ import annotations +import re from typing import Any from box.converters import _ruamel_to_builtin @@ -31,20 +32,24 @@ ] POSITIONS = ("before", "eol") +# Every character YAML treats as a line break. A comment line must never contain one, or the text +# after it would be read back as YAML content. +_LINE_BREAKS = re.compile("\r\n|[\r\n\x85\u2028\u2029]") +_CONTROL = re.compile("[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]") DOCUMENT_POSITIONS = ("start", "end") def _token_lines(value: str) -> list[str]: """Comment token text to comment lines without the "#", blank lines kept as "".""" out = [] - for line in value.split("\n"): + for line in _LINE_BREAKS.split(value): line = line.strip() out.append(line[1:].lstrip() if line.startswith("#") else line) return out def _text_to_lines(text: str) -> list[str]: - return [line[1:].lstrip() if line.strip().startswith("#") else line for line in text.split("\n")] + return [line[1:].lstrip() if line.strip().startswith("#") else line for line in _LINE_BREAKS.split(text)] def normalize(position: Any, text: Any, document: bool = False) -> Any: @@ -56,8 +61,10 @@ def normalize(position: Any, text: Any, document: bool = False) -> Any: return None if not isinstance(text, str): raise BoxValueError(f"comment must be a string, not {type(text).__name__}") + if _CONTROL.search(text): + raise BoxValueError("comments can't contain control characters") if position == "eol": - if "\n" in text: + if _LINE_BREAKS.search(text): raise BoxValueError("an end of line comment must be a single line") return _text_to_lines(text)[0] return _text_to_lines(text) diff --git a/test/test_comments.py b/test/test_comments.py index fa7e1b8..e685c43 100644 --- a/test/test_comments.py +++ b/test/test_comments.py @@ -396,3 +396,29 @@ def test_self_reference(self): assert bx.to_yaml() == "&id001\na: 1\nme: *id001\n" bx.set_comment("a", "x") assert "a: 1 # x" in bx.to_yaml() + + +class TestCommentTextIsNeverYaml: + @pytest.mark.parametrize("brk", ["\n", "\r", "\r\n", "\x85", "\u2028", "\u2029"]) + def test_end_of_line_comments_reject_every_line_break(self, brk): + with pytest.raises(BoxValueError, match="single line"): + Box(a=1).set_comment("a", f"x{brk}injected: 1") + + @pytest.mark.parametrize("brk", ["\n", "\r", "\r\n", "\x85", "\u2028", "\u2029"]) + @pytest.mark.parametrize("key, position", [("a", "before"), (None, "start"), (None, "end")]) + def test_multi_line_comments_stay_comments(self, brk, key, position): + bx = Box(a=1) + bx.set_comment(key, f"one{brk}injected: 1", position=position) + out = bx.to_yaml() + assert Box.from_yaml(out).to_dict() == {"a": 1}, out + assert "# injected: 1" in out + + @pytest.mark.parametrize("char", ["\x00", "\x08", "\x0b", "\x0c", "\x1b", "\x7f"]) + def test_control_characters_are_rejected(self, char): + with pytest.raises(BoxValueError, match="control characters"): + Box(a=1).set_comment("a", f"x{char}y", position="before") + + def test_tabs_are_fine(self): + bx = Box(a=1) + bx.set_comment("a", "x\ty") + assert Box.from_yaml(bx.to_yaml()).get_comment("a") == {"eol": "x\ty"}