brainlessdb 0.17.2__tar.gz → 0.17.4__tar.gz

brainlessdb-0.17.4/.python-version

@@ -0,0 +1 @@
+3.14

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 
 
+## [0.17.4] - 2026-11-03
+
+### 🐛 Bug Fixes
+
+- Validate registry on save so invalid values are never flushed
+   - Plain attribute assignment is not type-checked by msgspec, so e.g. None in
+a non-Optional field was flushed and every reader dead-lettered the entry. 
+
+
+## [0.17.3] - 2026-10-21
+
+### 🐛 Bug Fixes
+
+- Make update() atomic and unindex by recorded values, not mutated attributes
+
+
 ## [0.17.2] - 2026-08-22
 
 ### 🐛 Bug Fixes

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: brainlessdb
-Version: 0.17.2
+Version: 0.17.4
 Summary: Typed collections backed by NATS JetStream KV
 Author-email: "INSOFT s.r.o." <helpdesk@insoft.cz>
 License-Expression: MIT

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/brainlessdb/__init__.py

@@ -1,6 +1,6 @@
 """Brainless DB - Typed collections backed by NATS JetStream KV."""
 
-__version__ = "0.17.2"
+__version__ = "0.17.4"
 
 from typing import Any, Optional, TypeVar
 

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/brainlessdb/collection.py

@@ -188,6 +188,10 @@ class Collection(Generic[T]):
         self._indexes: dict[str, dict[Any, set[str]]] = {f: {} for f in self._analysis.indexed_fields}
         # Uniques: field -> value -> uid
         self._uniques: dict[str, dict[Any, str]] = {f: {} for f in self._analysis.unique_fields}
+        # What _index_add actually recorded per uid: (indexed values, unique values).
+        # Removal goes by these, never by the entity's current attributes - the
+        # stored object is often mutated in place before save() re-indexes it.
+        self._indexed: dict[str, tuple[dict[str, Any], dict[str, Any]]] = {}
 
         # Callbacks: list of (callback, trigger_local)
         self._on_change: list[tuple[Callable, bool]] = []
@@ -234,13 +238,19 @@ class Collection(Generic[T]):
     # === Indexing ===
 
     def _index_add(self, obj: T) -> None:
+        """(Re)index `obj`, replacing whatever was indexed for its uid before."""
         uid = str(obj.uuid)
+        self._index_remove(uid)
+        indexed: dict[str, Any] = {}
+        uniques: dict[str, Any] = {}
         for field in self._analysis.indexed_fields:
             val = getattr(obj, field, None)
             self._indexes[field].setdefault(val, set()).add(uid)
+            indexed[field] = val
         for field in self._analysis.unique_fields:
             val = getattr(obj, field, None)
             if val is not None:
+                uniques[field] = val
                 prev = self._uniques[field].get(val)
                 if prev is not None and prev != uid:
                     _log.warning(
@@ -248,18 +258,22 @@ class Collection(Generic[T]):
                         self.name, field, val, prev, uid,
                     )
                 self._uniques[field][val] = uid
+        self._indexed[uid] = (indexed, uniques)
 
-    def _index_remove(self, obj: T) -> None:
-        uid = str(obj.uuid)
-        for field in self._analysis.indexed_fields:
-            val = getattr(obj, field, None)
-            if val in self._indexes[field]:
-                self._indexes[field][val].discard(uid)
-                if not self._indexes[field][val]:
+    def _index_remove(self, uid: str) -> None:
+        """Drop the index/unique entries recorded for `uid` by _index_add."""
+        recorded = self._indexed.pop(uid, None)
+        if recorded is None:
+            return
+        indexed, uniques = recorded
+        for field, val in indexed.items():
+            uids = self._indexes[field].get(val)
+            if uids is not None:
+                uids.discard(uid)
+                if not uids:
                     del self._indexes[field][val]
-        for field in self._analysis.unique_fields:
-            val = getattr(obj, field, None)
-            if val is not None and self._uniques[field].get(val) == uid:
+        for field, val in uniques.items():
+            if self._uniques[field].get(val) == uid:
                 del self._uniques[field][val]
 
     def _check_unique(self, obj: T) -> None:
@@ -289,7 +303,7 @@ class Collection(Generic[T]):
         obj = self._entities.pop(uid, None)
         if obj is None:
             return None
-        self._index_remove(obj)
+        self._index_remove(uid)
         _unregister(obj.uuid)
         self._metadata.pop(uid, None)
         self._dirty.discard(uid)
@@ -468,8 +482,11 @@ class Collection(Generic[T]):
 
     # === CRUD ===
 
-    def add(self, obj: Union[T, dict[str, Any]]):
-        """Add or update struct in collection."""
+    def add(self, obj: Union[T, dict[str, Any]]) -> T:
+        """Add or update struct in collection.
+
+        Stores a validated copy (never `obj` itself) and returns it. Raises before
+        touching the collection when validation or a unique constraint fails."""
         # Pre-process dict to inject local class type tag if needed
         if isinstance(obj, dict) and "_" in obj and isinstance(obj["_"], dict):
             local = obj["_"]
@@ -487,15 +504,13 @@ class Collection(Generic[T]):
 
         self._check_unique(obj)
 
-        if old:
-            self._index_remove(old)
-
         self._entities[uid] = obj
         self._index_add(obj)
         self._dirty.add(uid)
         _register(obj.uuid, self)
         self._client.schedule_flush()
         self._fire_change(old, obj, local=True)
+        return obj
 
     def get(self, uuid: str) -> Optional[T]:
         return self._entities.get(uuid)
@@ -506,7 +521,7 @@ class Collection(Generic[T]):
         if not item:
             return False
 
-        self._index_remove(item)
+        self._index_remove(uid)
         _unregister(item.uuid)
         del self._entities[uid]
         self._dirty.discard(uid)
@@ -528,6 +543,7 @@ class Collection(Generic[T]):
             idx.clear()
         for uq in self._uniques.values():
             uq.clear()
+        self._indexed.clear()
 
     # === Filtering ===
 
@@ -730,7 +746,7 @@ class Collection(Generic[T]):
                     if e.operation == "DEL":
                         item = self._entities.get(uid)
                         if item:
-                            self._index_remove(item)
+                            self._index_remove(uid)
                             _unregister(item.uuid)
                             del self._entities[uid]
                             self._metadata.pop(uid, None)
@@ -760,8 +776,6 @@ class Collection(Generic[T]):
                                 continue
 
                             self._metadata[uid] = w.m
-                            if old:
-                                self._index_remove(old)
                             self._entities[uid] = new
                             self._index_add(new)
                             _register(new.uuid, self)
@@ -802,7 +816,6 @@ class Collection(Generic[T]):
                         if old_data == new_data:
                             continue
 
-                        self._index_remove(old)
                         if kind == "state":
                             new = self._from_parts(e.key, self._to_config(old), new_data, self._to_local(old))
                         else:

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/brainlessdb/registry.py

@@ -81,6 +81,13 @@ class Registry(Generic[T]):
     # === Dirty / save ===
 
     def mark_dirty(self) -> None:
+        """Validate the instance and schedule it for flush.
+
+        Plain attribute assignment is not type-checked by msgspec, so an invalid
+        value (e.g. None for a non-Optional field) is caught here and raises
+        msgspec.ValidationError before it can be flushed and break every reader.
+        """
+        self._apply(self._to_data())
         self._dirty = True
         self._client.schedule_flush()
 

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/brainlessdb/struct.py

@@ -91,7 +91,7 @@ class BrainlessBucket(Struct, kw_only=True, tag=True, tag_field="TYPE"):
     def save(self) -> None:
         """Mark entity as dirty in its collection."""
         collection = _registry.get(self._uuid)
-        if collection:
+        if collection is not None:
             collection.add(self)
 
     @classmethod
@@ -146,17 +146,31 @@ class BrainlessBucket(Struct, kw_only=True, tag=True, tag_field="TYPE"):
         return cls(**kwargs)
 
     def update(self, data: dict) -> "BrainlessBucket":
-        """Update fields from dict, supports nested structs."""
+        """Apply `data` atomically, validate, save and return self.
+
+        Keys that are not struct fields are ignored; a dict given for a field
+        holding a nested struct is merged into it. The merged result is fully
+        converted (lists of dicts become structs, ...) and saved before `self`
+        is touched: when validation or the collection (UniqueConstraintError)
+        rejects it, `self` and the collection are left unchanged. On success
+        `self` holds the converted values; like after save(), the collection
+        stores its own validated copy, so re-fetch to get the stored object.
+        """
+        fields = self.__struct_fields__
+        merged = to_builtins(self)
         for key, value in data.items():
-            if not hasattr(self, key):
+            if key not in fields:
                 continue
-            if isinstance(value, dict):
-                current = getattr(self, key)
-                if current is not None and hasattr(current, "__struct_fields__"):
-                    merged = {**to_builtins(current), **value}
-                    value = convert(merged, type(current))
-            setattr(self, key, value)
-        self.save()
+            current = getattr(self, key)
+            if isinstance(value, dict) and hasattr(current, "__struct_fields__"):
+                value = {**to_builtins(current), **value}
+            merged[key] = to_builtins(value)
+        new = convert(merged, type(self))
+        collection = _registry.get(self._uuid)
+        if collection is not None:
+            collection.add(new)
+        for f in fields:
+            setattr(self, f, getattr(new, f))
         return self
 
 
@@ -191,7 +205,10 @@ class BrainlessRegistry(Struct, kw_only=True, tag=True, tag_field="TYPE", dict=T
         return uuid5(_REGISTRY_NS, type(self).__key__)
 
     def save(self) -> None:
-        """Mark this registry entry dirty in its Registry."""
+        """Validate and mark this registry entry dirty in its Registry.
+
+        Raises msgspec.ValidationError when a field holds a value of wrong type.
+        """
         owner_ref = getattr(self, "_owner", None)
         owner = owner_ref() if owner_ref is not None else None
         if owner is not None:

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brainlessdb"
-version = "0.17.2"
+version = "0.17.4"
 description = "Typed collections backed by NATS JetStream KV"
 authors = [
     {name = "INSOFT s.r.o.", email = "helpdesk@insoft.cz"}

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/tests/test_registry.py

@@ -62,6 +62,21 @@ class TestRegistryBasics:
 class TestRegistryPersistence:
     """Save / reload through the shared bucket."""
 
+    @pytest.mark.asyncio
+    async def test_save_rejects_invalid_value(self):
+        nats = MockNats()
+        db = BrainlessDB(nats, namespace="loc1", flush_interval=0)
+        sip = db.registry(SipConfigV1)
+        await db.start()
+
+        sip.host = None  # not Optional
+        with pytest.raises(msgspec.ValidationError):
+            sip.save()
+        assert await db.flush() == 0
+        assert SipConfigV1.storage_key() not in await nats.jetstream()._buckets[REGISTRY_BUCKET].keys()
+
+        await db.stop()
+
     @pytest.mark.asyncio
     async def test_save_and_reload(self):
         nats = MockNats()

brainlessdb-0.17.4/tests/test_update_atomic.py

@@ -0,0 +1,243 @@
+"""Atomic update() and index bookkeeping.
+
+Production incident (Uniqa, ucs-server device sync): `update()` setattr'd the
+incoming values on the live entity before `save()` validated them. A unique
+clash made `save()` raise, leaving the live Device with `lines` as plain dicts
+(every `line.line_id` predicate then crashed) and the indexes keyed by values
+the entity no longer held. A second defect made it worse: `Collection.add()`
+removed index entries using the *old* object, which was the same live object
+the caller had just mutated, so the previously indexed values were never
+removed and later swaps clashed on values nobody held any more.
+"""
+
+from typing import Annotated, Optional, Union
+
+import msgspec
+import pytest
+from msgspec import Meta
+
+from brainlessdb import BrainlessBucket, BrainlessDBFeat, BrainlessStruct, UniqueConstraintError
+from tests.conftest import UniqueUserV1
+
+
+class LineExtensionV1(BrainlessStruct):
+    line_id: int = 0
+    extension_id: int = 0
+
+
+class LineTrunkV1(BrainlessStruct):
+    line_id: int = 0
+    trunk_id: int = 0
+
+
+class SettingsV1(BrainlessStruct):
+    codec: str = "opus"
+    volume: int = 5
+
+
+class GadgetV1(BrainlessBucket):
+    @staticmethod
+    def allows_app(app: str) -> bool:
+        return True
+
+    id: int = 0
+    mac: Annotated[Optional[str], Meta(extra={"brainlessdb_flags": BrainlessDBFeat.UNIQUE})] = None
+    group: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX})] = 0
+    lines: list[Union[LineExtensionV1, LineTrunkV1]] = []
+    settings: Optional[SettingsV1] = None
+
+
+@pytest.fixture
+async def gadgets(db):
+    coll = db.collection(GadgetV1)
+    await db.start()
+    return coll
+
+
+def _snapshot(coll) -> tuple:
+    return (
+        {f: {v: set(u) for v, u in idx.items()} for f, idx in coll._indexes.items()},
+        {f: dict(uq) for f, uq in coll._uniques.items()},
+    )
+
+
+class TestUpdateAtomic:
+    @pytest.mark.asyncio
+    async def test_rejected_by_unique_clash_leaves_entity_and_indexes_unchanged(self, gadgets):
+        gadgets.add(GadgetV1(id=1, mac="aa", group=1, lines=[LineExtensionV1(line_id=1, extension_id=10)]))
+        gadgets.add(GadgetV1(id=2, mac="bb", group=1))
+        live = gadgets.find(id=2)
+        before = msgspec.to_builtins(live)
+        indexes = _snapshot(gadgets)
+
+        with pytest.raises(UniqueConstraintError):
+            live.update(
+                {
+                    "mac": "aa",
+                    "group": 7,
+                    "lines": [{"TYPE": "LineExtensionV1", "line_id": 5, "extension_id": 50}],
+                    "settings": {"volume": 9},
+                }
+            )
+
+        assert gadgets.find(id=2) is live
+        assert msgspec.to_builtins(live) == before
+        assert live.lines == []
+        assert live.settings is None
+        assert _snapshot(gadgets) == indexes
+
+    @pytest.mark.asyncio
+    async def test_rejected_by_validation_leaves_entity_unchanged(self, gadgets):
+        gadgets.add(GadgetV1(id=1, mac="aa", lines=[LineTrunkV1(line_id=1, trunk_id=3)]))
+        live = gadgets.find(id=1)
+        before = msgspec.to_builtins(live)
+
+        with pytest.raises(msgspec.ValidationError):
+            live.update({"id": 9, "lines": [{"TYPE": "LineExtensionV1", "line_id": "not-an-int"}]})
+
+        assert msgspec.to_builtins(live) == before
+        assert isinstance(live.lines[0], LineTrunkV1)
+
+    @pytest.mark.asyncio
+    async def test_list_of_dicts_becomes_structs(self, gadgets):
+        gadgets.add(GadgetV1(id=1, mac="aa"))
+        live = gadgets.find(id=1)
+
+        result = live.update(
+            {
+                "lines": [
+                    {"TYPE": "LineExtensionV1", "line_id": 1, "extension_id": 10},
+                    {"TYPE": "LineTrunkV1", "line_id": 2, "trunk_id": 20},
+                ]
+            }
+        )
+
+        assert result is live
+        for obj in (live, gadgets.find(id=1)):
+            assert [type(line) for line in obj.lines] == [LineExtensionV1, LineTrunkV1]
+            assert [line.line_id for line in obj.lines] == [1, 2]
+
+    @pytest.mark.asyncio
+    async def test_dict_merges_into_nested_struct_and_unknown_keys_ignored(self, gadgets):
+        gadgets.add(GadgetV1(id=1, mac="aa", settings=SettingsV1(codec="pcma", volume=3)))
+        live = gadgets.find(id=1)
+
+        live.update({"settings": {"volume": 8}, "nope": 1, "uuid": "ignored", "save": None})
+
+        stored = gadgets.find(id=1)
+        assert stored.settings == SettingsV1(codec="pcma", volume=8)
+        assert live.settings == SettingsV1(codec="pcma", volume=8)
+
+    @pytest.mark.asyncio
+    async def test_dict_for_empty_nested_struct_is_converted(self, gadgets):
+        gadgets.add(GadgetV1(id=1, mac="aa"))
+        live = gadgets.find(id=1)
+
+        live.update({"settings": {"volume": 4}})
+
+        assert live.settings == SettingsV1(volume=4)
+        assert gadgets.find(id=1).settings == SettingsV1(volume=4)
+
+    @pytest.mark.asyncio
+    async def test_update_detached_entity_validates_without_collection(self):
+        g = GadgetV1(id=1, lines=[])
+        with pytest.raises(msgspec.ValidationError):
+            g.update({"id": "x"})
+        assert g.id == 1
+        g.update({"lines": [{"TYPE": "LineTrunkV1", "line_id": 4}]})
+        assert isinstance(g.lines[0], LineTrunkV1)
+
+    @pytest.mark.asyncio
+    async def test_swap_unique_values_via_temporary(self, gadgets):
+        gadgets.add(GadgetV1(id=1, mac="aa"))
+        gadgets.add(GadgetV1(id=2, mac="bb"))
+
+        gadgets.find(id=1).update({"mac": "tmp"})
+        gadgets.find(id=2).update({"mac": "aa"})
+        gadgets.find(id=1).update({"mac": "bb"})
+
+        assert gadgets.find(id=1).mac == "bb"
+        assert gadgets.find(id=2).mac == "aa"
+        one, two = str(gadgets.find(id=1).uuid), str(gadgets.find(id=2).uuid)
+        assert gadgets._uniques["mac"] == {"bb": one, "aa": two}
+
+    @pytest.mark.asyncio
+    async def test_swap_unique_values_via_save(self, gadgets):
+        gadgets.add(GadgetV1(id=1, mac="aa"))
+        gadgets.add(GadgetV1(id=2, mac="bb"))
+
+        g1 = gadgets.find(id=1)
+        g1.mac = "tmp"
+        g1.save()
+        g2 = gadgets.find(id=2)
+        g2.mac = "aa"
+        g2.save()
+        g1 = gadgets.find(id=1)
+        g1.mac = "bb"
+        g1.save()
+
+        one, two = str(gadgets.find(id=1).uuid), str(gadgets.find(id=2).uuid)
+        assert gadgets._uniques["mac"] == {"bb": one, "aa": two}
+
+    @pytest.mark.asyncio
+    async def test_index_moves_on_update(self, gadgets):
+        gadgets.add(GadgetV1(id=1, mac="aa", group=1))
+        uid = str(gadgets.find(id=1).uuid)
+
+        gadgets.find(id=1).update({"group": 2})
+
+        assert gadgets._indexes["group"] == {2: {uid}}
+        assert gadgets.filter(group=1) == []
+        assert [g.id for g in gadgets.filter(group=2)] == [1]
+
+
+class TestInPlaceMutationIndexes:
+    @pytest.mark.asyncio
+    async def test_in_place_mutation_then_unique_change_leaves_no_stale_entries(self, unique_users):
+        unique_users.add(UniqueUserV1(id=1, email="a@x"))
+        uid = str(unique_users.find(id=1).uuid)
+
+        live = unique_users.find(id=1)
+        live.email = "b@x"
+        live.save()
+        live = unique_users.find(id=1)
+        live.email = "c@x"
+        live.save()
+
+        assert unique_users._uniques["email"] == {"c@x": uid}
+        # both previous values are free again
+        unique_users.add(UniqueUserV1(id=2, email="a@x"))
+        unique_users.add(UniqueUserV1(id=3, email="b@x"))
+
+    @pytest.mark.asyncio
+    async def test_own_unique_value_change_does_not_clash_with_itself(self, unique_users):
+        unique_users.add(UniqueUserV1(id=1, email="a@x"))
+        live = unique_users.find(id=1)
+        live.email = "b@x"
+        live.save()
+        live = unique_users.find(id=1)
+        live.email = "a@x"
+        live.save()
+        assert unique_users.find(id=1).email == "a@x"
+        assert unique_users._uniques["email"] == {"a@x": str(live.uuid)}
+
+    @pytest.mark.asyncio
+    async def test_delete_after_in_place_mutation_frees_indexed_value(self, unique_users):
+        unique_users.add(UniqueUserV1(id=1, email="a@x"))
+        live = unique_users.find(id=1)
+        live.email = "b@x"  # mutated, never saved
+        unique_users.delete(live)
+
+        assert unique_users._uniques["email"] == {}
+        unique_users.add(UniqueUserV1(id=2, email="a@x"))
+
+    @pytest.mark.asyncio
+    async def test_rejected_save_keeps_index_on_stored_values(self, unique_users):
+        unique_users.add(UniqueUserV1(id=1, email="a@x"))
+        unique_users.add(UniqueUserV1(id=2, email="b@x"))
+        live = unique_users.find(id=2)
+        live.email = "a@x"
+        with pytest.raises(UniqueConstraintError):
+            live.save()
+        one = str(unique_users.find(id=1).uuid)
+        assert unique_users._uniques["email"] == {"a@x": one, "b@x": str(live.uuid)}

{brainlessdb-0.17.2 → brainlessdb-0.17.4}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.9"
 resolution-markers = [
     "python_full_version >= '3.10'",
@@ -17,7 +17,7 @@ wheels = [
 
 [[package]]
 name = "brainlessdb"
-version = "0.17.1"
+version = "0.17.3"
 source = { editable = "." }
 dependencies = [
     { name = "msgspec" },
@@ -60,7 +60,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -196,13 +196,13 @@ resolution-markers = [
     "python_full_version < '3.10'",
 ]
 dependencies = [
-    { name = "colorama", marker = "python_full_version < '3.10' and sys_platform == 'win32'" },
-    { name = "exceptiongroup", marker = "python_full_version < '3.10'" },
-    { name = "iniconfig", version = "2.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
-    { name = "packaging", marker = "python_full_version < '3.10'" },
-    { name = "pluggy", marker = "python_full_version < '3.10'" },
-    { name = "pygments", marker = "python_full_version < '3.10'" },
-    { name = "tomli", marker = "python_full_version < '3.10'" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup" },
+    { name = "iniconfig", version = "2.1.0", source = { registry = "https://pypi.org/simple" } },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
 wheels = [
@@ -217,13 +217,13 @@ resolution-markers = [
     "python_full_version >= '3.10'",
 ]
 dependencies = [
-    { name = "colorama", marker = "python_full_version >= '3.10' and sys_platform == 'win32'" },
-    { name = "exceptiongroup", marker = "python_full_version == '3.10.*'" },
-    { name = "iniconfig", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
-    { name = "packaging", marker = "python_full_version >= '3.10'" },
-    { name = "pluggy", marker = "python_full_version >= '3.10'" },
-    { name = "pygments", marker = "python_full_version >= '3.10'" },
-    { name = "tomli", marker = "python_full_version == '3.10.*'" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig", version = "2.3.0", source = { registry = "https://pypi.org/simple" } },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
 wheels = [
@@ -238,9 +238,9 @@ resolution-markers = [
     "python_full_version < '3.10'",
 ]
 dependencies = [
-    { name = "backports-asyncio-runner", marker = "python_full_version < '3.10'" },
-    { name = "pytest", version = "8.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
-    { name = "typing-extensions", marker = "python_full_version < '3.10'" },
+    { name = "backports-asyncio-runner" },
+    { name = "pytest", version = "8.4.2", source = { registry = "https://pypi.org/simple" } },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/42/86/9e3c5f48f7b7b638b216e4b9e645f54d199d7abbbab7a64a13b4e12ba10f/pytest_asyncio-1.2.0.tar.gz", hash = "sha256:c609a64a2a8768462d0c99811ddb8bd2583c33fd33cf7f21af1c142e824ffb57", size = 50119, upload-time = "2025-09-12T07:33:53.816Z" }
 wheels = [
@@ -255,9 +255,9 @@ resolution-markers = [
     "python_full_version >= '3.10'",
 ]
 dependencies = [
-    { name = "backports-asyncio-runner", marker = "python_full_version == '3.10.*'" },
-    { name = "pytest", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
-    { name = "typing-extensions", marker = "python_full_version >= '3.10' and python_full_version < '3.13'" },
+    { name = "backports-asyncio-runner", marker = "python_full_version < '3.11'" },
+    { name = "pytest", version = "9.0.2", source = { registry = "https://pypi.org/simple" } },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
 wheels = [

brainlessdb-0.17.2/.python-version

@@ -1 +0,0 @@
-3.9