brainlessdb 0.6.0__tar.gz → 0.7.2__tar.gz

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/CHANGELOG.md

@@ -3,6 +3,31 @@
 All notable changes to this project will be documented in this file.
 
 
+## [0.7.2] - 2026-02-08
+
+### 🐛 Bug Fixes
+
+- Commit pyproject.toml and brainlessdb/__init__.py on just release
+
+
+## [0.7.1] - 2026-02-08
+
+### Fchore
+
+- Renamed BrainlessStruct to BrainlessBucket and NestedStruct to BrainlessStruct
+
+
+## [0.7.0] - 2026-02-06
+
+### 🚀 Features
+
+- When deserialization fails log error and move on
+
+### 🐛 Bug Fixes
+
+- Preserve None fields in config serialization to prevent ValidationError on reload
+
+
 ## [0.6.0] - 2026-02-05
 
 ### 🚀 Features

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainlessdb
-Version: 0.6.0
+Version: 0.7.2
 Summary: Typed collections backed by NATS JetStream KV
 Author-email: "INSOFT s.r.o." <helpdesk@insoft.cz>
 License-Expression: MIT
@@ -18,9 +18,9 @@ Typed collections backed by NATS JetStream KV. In-memory with background sync.
 ```python
 from typing import Annotated
 from msgspec import Meta
-from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessStruct
+from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessBucket
 
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX})]
     name: Annotated[str, Meta()] = ""
 
@@ -46,24 +46,24 @@ await db.stop()
 
 | Class | Use for | Has UUID | Stored in |
 |-------|---------|----------|-----------|
-| `BrainlessStruct` | Main entities (User, Order, etc.) | Yes | Own bucket(s) |
-| `NestedStruct` | Nested data, app-local data | No | Inside parent entity |
+| `BrainlessBucket` | Main entities (User, Order, etc.) | Yes | Own bucket(s) |
+| `BrainlessStruct` | Nested data, app-local data | No | Inside parent entity |
 
 ```python
-from brainlessdb import BrainlessStruct, NestedStruct
+from brainlessdb import BrainlessBucket, BrainlessStruct
 
-# App-local data - NestedStruct (no UUID, not an entity)
-class UcsLocal(NestedStruct):
+# App-local data - BrainlessStruct (no UUID, not an entity)
+class UcsLocal(BrainlessStruct):
     sid: int = 0
     pointer: int = 0
 
-# Nested data - NestedStruct
-class Address(NestedStruct):
+# Nested data - BrainlessStruct
+class Address(BrainlessStruct):
     street: str = ""
     city: str = ""
 
-# Main entity - BrainlessStruct (has UUID, stored in NATS)
-class UserV1(BrainlessStruct):
+# Main entity - BrainlessBucket (has UUID, stored in NATS)
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta()]
     address: Optional[Address] = None  # nested struct
     _: Optional[UcsLocal] = None       # app-local struct
@@ -87,7 +87,7 @@ await brainlessdb.stop()
 Persistent data synced across all instances:
 
 ```python
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta()]
     name: Annotated[str, Meta()] = ""
 ```
@@ -96,7 +96,7 @@ class UserV1(BrainlessStruct):
 Ephemeral data (separate bucket, faster sync):
 
 ```python
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta()]
     status: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.STATE})] = 0
 ```
@@ -105,7 +105,7 @@ class UserV1(BrainlessStruct):
 Fast O(1) lookups:
 
 ```python
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX})]
 ```
 
@@ -113,7 +113,7 @@ class UserV1(BrainlessStruct):
 Enforces uniqueness constraint (also auto-indexed):
 
 ```python
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     email: Annotated[Optional[str], Meta(extra={"brainlessdb_flags": BrainlessDBFeat.UNIQUE})] = None
 ```
 
@@ -127,16 +127,16 @@ counter: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX |
 Data private to each namespace:
 
 ```python
-from brainlessdb import BrainlessStruct, NestedStruct
+from brainlessdb import BrainlessBucket, BrainlessStruct
 
-class UcsLocal(NestedStruct):
+class UcsLocal(BrainlessStruct):
     sid: int = 0
 
-class AriLocal(NestedStruct):
+class AriLocal(BrainlessStruct):
     channel_id: str = ""
 
 # Entity with app-local field
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta()]
     _: Union[UcsLocal, AriLocal, None] = None
 ```

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/README.md

@@ -7,9 +7,9 @@ Typed collections backed by NATS JetStream KV. In-memory with background sync.
 ```python
 from typing import Annotated
 from msgspec import Meta
-from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessStruct
+from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessBucket
 
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX})]
     name: Annotated[str, Meta()] = ""
 
@@ -35,24 +35,24 @@ await db.stop()
 
 | Class | Use for | Has UUID | Stored in |
 |-------|---------|----------|-----------|
-| `BrainlessStruct` | Main entities (User, Order, etc.) | Yes | Own bucket(s) |
-| `NestedStruct` | Nested data, app-local data | No | Inside parent entity |
+| `BrainlessBucket` | Main entities (User, Order, etc.) | Yes | Own bucket(s) |
+| `BrainlessStruct` | Nested data, app-local data | No | Inside parent entity |
 
 ```python
-from brainlessdb import BrainlessStruct, NestedStruct
+from brainlessdb import BrainlessBucket, BrainlessStruct
 
-# App-local data - NestedStruct (no UUID, not an entity)
-class UcsLocal(NestedStruct):
+# App-local data - BrainlessStruct (no UUID, not an entity)
+class UcsLocal(BrainlessStruct):
     sid: int = 0
     pointer: int = 0
 
-# Nested data - NestedStruct
-class Address(NestedStruct):
+# Nested data - BrainlessStruct
+class Address(BrainlessStruct):
     street: str = ""
     city: str = ""
 
-# Main entity - BrainlessStruct (has UUID, stored in NATS)
-class UserV1(BrainlessStruct):
+# Main entity - BrainlessBucket (has UUID, stored in NATS)
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta()]
     address: Optional[Address] = None  # nested struct
     _: Optional[UcsLocal] = None       # app-local struct
@@ -76,7 +76,7 @@ await brainlessdb.stop()
 Persistent data synced across all instances:
 
 ```python
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta()]
     name: Annotated[str, Meta()] = ""
 ```
@@ -85,7 +85,7 @@ class UserV1(BrainlessStruct):
 Ephemeral data (separate bucket, faster sync):
 
 ```python
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta()]
     status: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.STATE})] = 0
 ```
@@ -94,7 +94,7 @@ class UserV1(BrainlessStruct):
 Fast O(1) lookups:
 
 ```python
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX})]
 ```
 
@@ -102,7 +102,7 @@ class UserV1(BrainlessStruct):
 Enforces uniqueness constraint (also auto-indexed):
 
 ```python
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     email: Annotated[Optional[str], Meta(extra={"brainlessdb_flags": BrainlessDBFeat.UNIQUE})] = None
 ```
 
@@ -116,16 +116,16 @@ counter: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX |
 Data private to each namespace:
 
 ```python
-from brainlessdb import BrainlessStruct, NestedStruct
+from brainlessdb import BrainlessBucket, BrainlessStruct
 
-class UcsLocal(NestedStruct):
+class UcsLocal(BrainlessStruct):
     sid: int = 0
 
-class AriLocal(NestedStruct):
+class AriLocal(BrainlessStruct):
     channel_id: str = ""
 
 # Entity with app-local field
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     id: Annotated[int, Meta()]
     _: Union[UcsLocal, AriLocal, None] = None
 ```

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/brainlessdb/__init__.py

@@ -1,19 +1,19 @@
 """Brainless DB - Typed collections backed by NATS JetStream KV."""
 
-__version__ = "0.6.0"
+__version__ = "0.7.2"
 
 from typing import Any, Optional, TypeVar
 
 from .client import BrainlessDB
 from .collection import Collection, HasUUID
-from .struct import BrainlessDBFeat, BrainlessStruct, NestedStruct, UniqueConstraintError
+from .struct import BrainlessDBFeat, BrainlessBucket, BrainlessStruct, UniqueConstraintError
 
 __all__ = [
     "__version__",
     "BrainlessDB",
     "BrainlessDBFeat",
+    "BrainlessBucket",
     "BrainlessStruct",
-    "NestedStruct",
     "Collection",
     "HasUUID",
     "UniqueConstraintError",

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/brainlessdb/bucket.py

@@ -28,6 +28,10 @@ class Bucket:
     def __init__(self, kv: Any):
         self._kv = kv
 
+    @property
+    def name(self) -> str:
+        return self._kv.name
+
     @classmethod
     async def create(cls, js: Any, name: str) -> "Bucket":
         """Create or get existing KV bucket."""

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/brainlessdb/collection.py

@@ -11,7 +11,7 @@ import msgspec
 from .bucket import Bucket
 from .fields import analyze_fields
 from .struct import (
-    BrainlessStruct,
+    BrainlessBucket,
     ConfigWrapper,
     UniqueConstraintError,
     _register,
@@ -45,8 +45,8 @@ class Collection(Generic[T]):
     """Collection of structs backed by NATS KV buckets."""
 
     def __init__(self, client: "BrainlessDB", cls: type[T]) -> None:
-        if BrainlessStruct not in cls.__bases__:
-            raise TypeError(f"{cls.__name__} must directly inherit from BrainlessStruct")
+        if BrainlessBucket not in cls.__bases__:
+            raise TypeError(f"{cls.__name__} must directly inherit from BrainlessBucket")
 
         self._client = client
         self._cls = cls
@@ -156,8 +156,7 @@ class Collection(Generic[T]):
         data = {}
         for f in self._analysis.config_fields:
             val = getattr(obj, f, None)
-            if val is not None:
-                data[f] = msgspec.to_builtins(val) if hasattr(val, "__struct_fields__") else val
+            data[f] = msgspec.to_builtins(val) if hasattr(val, "__struct_fields__") else val
         return data
 
     def _to_state(self, obj: T) -> dict[str, Any]:
@@ -202,7 +201,13 @@ class Collection(Generic[T]):
     async def _load_bucket(bucket: Optional[Bucket]) -> dict[str, dict]:
         if not bucket:
             return {}
-        return {k: msgspec.json.decode(v) for k, v in (await bucket.all()).items()}
+        result: dict[str, dict] = {}
+        for k, v in (await bucket.all()).items():
+            try:
+                result[k] = msgspec.json.decode(v)
+            except Exception as ex:
+                _log.error("Failed to decode key '%s' from bucket '%s': %s", k, bucket.name, ex)
+        return result
 
     # === CRUD ===
 
@@ -336,7 +341,11 @@ class Collection(Generic[T]):
         config_entries: dict[str, tuple[dict, Any]] = {}
         if self._config_bucket:
             for uid, raw in (await self._config_bucket.all()).items():
-                w = msgspec.json.decode(raw, type=ConfigWrapper)
+                try:
+                    w = msgspec.json.decode(raw, type=ConfigWrapper)
+                except Exception as ex:
+                    _log.error("Failed to decode config for '%s' in '%s': %s", uid, self.name, ex)
+                    continue
                 config_entries[uid] = (w.d, w.m)
                 self._metadata[uid] = w.m
 
@@ -345,15 +354,20 @@ class Collection(Generic[T]):
 
         # Build entities
         for uid, (cfg, _) in config_entries.items():
-            obj = self._from_parts(uid, cfg, state.get(uid), local.get(uid))
+            try:
+                obj = self._from_parts(uid, cfg, state.get(uid), local.get(uid))
+            except Exception as ex:
+                _log.error("Failed to build entity '%s' in '%s': %s", uid, self.name, ex)
+                continue
             self._entities[uid] = obj
             self._index_add(obj)
             _register(obj.uuid, self)
 
         self._loaded = True
-        if config_entries:
-            _log.info("Loaded %d entities into '%s'", len(config_entries), self.name)
-        return len(config_entries)
+        count = len(self._entities)
+        if count:
+            _log.info("Loaded %d entities into '%s'", count, self.name)
+        return count
 
     async def flush(self) -> int:
         connected = await self._ensure_buckets()

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/brainlessdb/struct.py

@@ -38,11 +38,11 @@ def _unregister(uuid: UUID) -> None:
     _registry.pop(uuid, None)
 
 
-class NestedStruct(Struct, tag=True, tag_field="TYPE"):
+class BrainlessStruct(Struct, tag=True, tag_field="TYPE"):
     """Base struct for nested/embedded types."""
 
 
-class BrainlessStruct(Struct, kw_only=True, tag=True, tag_field="TYPE"):
+class BrainlessBucket(Struct, kw_only=True, tag=True, tag_field="TYPE"):
     """Base struct for brainlessdb entities."""
 
     _uuid: UUID = field(default_factory=uuid1)
@@ -57,7 +57,7 @@ class BrainlessStruct(Struct, kw_only=True, tag=True, tag_field="TYPE"):
         if collection:
             collection.add(self)
 
-    def update(self, data: dict) -> "BrainlessStruct":
+    def update(self, data: dict) -> "BrainlessBucket":
         """Update fields from dict, supports nested structs."""
         for key, value in data.items():
             if not hasattr(self, key):

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/justfile

@@ -6,7 +6,7 @@ create-changelog:
 release: create-changelog
     awk -i inplace '{ sub(/^version = "[0-9]+\.[0-9]+\.[0-9]+"/, "version = \"{{next_version}}\"") }; { print }' pyproject.toml
     awk -i inplace '{ sub(/^__version__ = "[0-9]+\.[0-9]+\.[0-9]+"/, "__version__ = \"{{next_version}}\"") }; { print }' brainlessdb/__init__.py
-    git add --ignore-errors CHANGELOG.md
+    git add --ignore-errors CHANGELOG.md pyproject.toml uv.lock brainlessdb/__init__.py
     git commit -m {{next_version}}
     git tag -a {{next_version}} -m {{next_version}}
 

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/pyproject.toml

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

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/test_results.txt

@@ -425,14 +425,14 @@ self = <tests.test_deserialization.TestRealWorldUserPattern object at 0x720273f1
         """Test Optional[Annotated[int, Meta(...)]] pattern like queue_reason."""
         from enum import IntEnum
         import msgspec
-        from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessBucket
         from brainlessdb.struct import ConfigWrapper
-    
+
         class Status(IntEnum):
             OFFLINE = 0
             ONLINE = 1
-    
-        class UserLike(BrainlessStruct):
+
+        class UserLike(BrainlessBucket):
             id: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX})] = 0
             group_id: int = 0
             # Pattern from queue_reason - Optional[Annotated[int, ...]]
@@ -440,7 +440,7 @@ self = <tests.test_deserialization.TestRealWorldUserPattern object at 0x720273f1
             queue_status_changed: Optional[Annotated[int, Meta(description="")]] = None
             # State field with enum
             status: Annotated[Status, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.STATE})] = Status.OFFLINE
-    
+
         db = BrainlessDB(namespace="test")
 >       coll = await db.collection(UserLike)
 E       TypeError: object Collection can't be used in 'await' expression
@@ -454,17 +454,17 @@ self = <tests.test_deserialization.TestRealWorldUserPattern object at 0x720273f1
     async def test_nested_struct_pattern(self):
         """Test nested struct like AgentChannelsV1."""
         import msgspec
-        from brainlessdb import BrainlessDB, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessBucket
         from brainlessdb.struct import ConfigWrapper
-    
+
         class Channels(Struct):
             voice: int = 0
             chat: int = 0
-    
-        class UserWithChannels(BrainlessStruct):
+
+        class UserWithChannels(BrainlessBucket):
             id: int = 0
             channels: Channels = field(default_factory=Channels)
-    
+
         db = BrainlessDB(namespace="test")
 >       coll = await db.collection(UserWithChannels)
 E       TypeError: object Collection can't be used in 'await' expression
@@ -478,17 +478,17 @@ self = <tests.test_deserialization.TestRealWorldUserPattern object at 0x720273f1
     async def test_vcard_list_pattern(self):
         """Test list of nested structs like vcard: list[VCardV1]."""
         import msgspec
-        from brainlessdb import BrainlessDB, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessBucket
         from brainlessdb.struct import ConfigWrapper
-    
+
         class VCard(Struct):
             name: str = ""
             value: str = ""
-    
-        class UserWithVCard(BrainlessStruct):
+
+        class UserWithVCard(BrainlessBucket):
             id: int = 0
             vcard: Optional[list[VCard]] = None
-    
+
         db = BrainlessDB(namespace="test")
 >       coll = await db.collection(UserWithVCard)
 E       TypeError: object Collection can't be used in 'await' expression
@@ -501,18 +501,18 @@ self = <tests.test_deserialization.TestLocalClassDetection object at 0x720273f19
     @pytest.mark.asyncio
     async def test_optional_annotated_union_pattern(self):
         """Test Optional[Annotated[Union[A, B], Meta()]] pattern from UserV2."""
-        from brainlessdb import BrainlessDB, BrainlessStruct
-    
+        from brainlessdb import BrainlessDB, BrainlessBucket
+
         class AriLocal(Struct):
             counter: int = 0
-    
+
         class UcsLocal(Struct):
             counter: int = 0
-    
-        class UserWithUnionLocal(BrainlessStruct):
+
+        class UserWithUnionLocal(BrainlessBucket):
             id: int = 0
             _: Optional[Annotated[Union[UcsLocal, AriLocal], Meta()]] = None
-    
+
         # Test with "ari" namespace - should find AriLocal
         db_ari = BrainlessDB(namespace="ari")
 >       coll_ari = await db_ari.collection(UserWithUnionLocal)
@@ -526,15 +526,15 @@ self = <tests.test_deserialization.TestLocalClassDetection object at 0x720273f19
     @pytest.mark.asyncio
     async def test_optional_single_class_pattern(self):
         """Test Optional[LocalClass] pattern."""
-        from brainlessdb import BrainlessDB, BrainlessStruct
-    
+        from brainlessdb import BrainlessDB, BrainlessBucket
+
         class TestLocal(Struct):
             value: int = 0
-    
-        class UserWithLocal(BrainlessStruct):
+
+        class UserWithLocal(BrainlessBucket):
             id: int = 0
             _: Optional[TestLocal] = None
-    
+
         db = BrainlessDB(namespace="test")
 >       coll = await db.collection(UserWithLocal)
 E       TypeError: object Collection can't be used in 'await' expression
@@ -547,18 +547,18 @@ self = <tests.test_deserialization.TestLocalClassDetection object at 0x720273f12
     @pytest.mark.asyncio
     async def test_union_without_optional_pattern(self):
         """Test Union[A, B] (without Optional) pattern."""
-        from brainlessdb import BrainlessDB, BrainlessStruct
-    
+        from brainlessdb import BrainlessDB, BrainlessBucket
+
         class AriData(Struct):
             x: int = 0
-    
+
         class UcsData(Struct):
             x: int = 0
-    
-        class UserUnion(BrainlessStruct):
+
+        class UserUnion(BrainlessBucket):
             id: int = 0
             _: Union[UcsData, AriData] = field(default_factory=UcsData)
-    
+
         db = BrainlessDB(namespace="ari")
 >       coll = await db.collection(UserUnion)
 E       TypeError: object Collection can't be used in 'await' expression
@@ -572,12 +572,12 @@ self = <tests.test_sync.TestMultiLocationSync object at 0x720273f197c0>
     async def test_two_locations_see_same_data(self):
         """Both locations can read data written by either."""
         nats = MockNats()
-    
+
         db1 = BrainlessDB(nats, namespace="loc1", flush_interval=0)
         db2 = BrainlessDB(nats, namespace="loc2", flush_interval=0)
         await db1.start()
         await db2.start()
-    
+
 >       users1 = await db1.collection(UserV1)
 E       TypeError: object Collection can't be used in 'await' expression
 
@@ -590,12 +590,12 @@ self = <tests.test_sync.TestMultiLocationSync object at 0x720273f125b0>
     async def test_watch_receives_remote_changes(self):
         """Watch fires when other location makes changes."""
         nats = MockNats()
-    
+
         db1 = BrainlessDB(nats, namespace="loc1", flush_interval=0)
         db2 = BrainlessDB(nats, namespace="loc2", flush_interval=0)
         await db1.start()
         await db2.start()
-    
+
 >       users1 = await db1.collection(UserV1)
 E       TypeError: object Collection can't be used in 'await' expression
 
@@ -608,10 +608,10 @@ self = <tests.test_sync.TestMultiLocationSync object at 0x720273eadd00>
     async def test_location_tracked_in_metadata(self):
         """Config bucket tracks which location made the change."""
         nats = MockNats()
-    
+
         db1 = BrainlessDB(nats, namespace="loc1", flush_interval=0)
         await db1.start()
-    
+
 >       users1 = await db1.collection(UserV1)
 E       TypeError: object Collection can't be used in 'await' expression
 
@@ -624,12 +624,12 @@ self = <tests.test_sync.TestMultiLocationSync object at 0x720273ead040>
     async def test_remote_delete_fires_event(self):
         """Delete from one location fires event on other."""
         nats = MockNats()
-    
+
         db1 = BrainlessDB(nats, namespace="loc1", flush_interval=0)
         db2 = BrainlessDB(nats, namespace="loc2", flush_interval=0)
         await db1.start()
         await db2.start()
-    
+
 >       users1 = await db1.collection(UserV1)
 E       TypeError: object Collection can't be used in 'await' expression
 

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/tests/conftest.py

@@ -5,10 +5,10 @@ from typing import Annotated, Optional
 import pytest
 from msgspec import Meta
 
-from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessStruct
+from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessBucket
 
 
-class UserV1(BrainlessStruct):
+class UserV1(BrainlessBucket):
     """Test user struct with indexed username."""
 
     id: Annotated[int, Meta()] = 0
@@ -20,21 +20,21 @@ class UserV1(BrainlessStruct):
     active: Annotated[bool, Meta()] = True
 
 
-class ChannelV1(BrainlessStruct):
+class ChannelV1(BrainlessBucket):
     """Test channel struct."""
 
     id: Annotated[str, Meta()] = ""
     name: Annotated[str, Meta()] = ""
 
 
-class AgentV1(BrainlessStruct):
+class AgentV1(BrainlessBucket):
     """Test agent struct."""
 
     id: Annotated[int, Meta()] = 0
     channel: Optional[ChannelV1] = None
 
 
-class QueueItemV1(BrainlessStruct):
+class QueueItemV1(BrainlessBucket):
     """Test queue item with nested structs."""
 
     inbound_id: Annotated[
@@ -45,7 +45,7 @@ class QueueItemV1(BrainlessStruct):
     agents: Optional[AgentV1] = None
 
 
-class UniqueUserV1(BrainlessStruct):
+class UniqueUserV1(BrainlessBucket):
     """Test struct with UNIQUE field."""
 
     id: int = 0

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/tests/test_collection.py

@@ -515,3 +515,99 @@ class TestUnique:
         unique_users.add(UniqueUserV1(id=1, email=""))
         with pytest.raises(UniqueConstraintError):
             unique_users.add(UniqueUserV1(id=2, email=""))
+
+
+class TestOptionalFieldRoundTrip:
+    """Test that Optional fields without defaults survive config round-trip."""
+
+    @pytest.mark.asyncio
+    async def test_none_optional_field_preserved_in_config(self):
+        """Optional field set to None must be stored and restored."""
+        from typing import Optional
+
+        from brainlessdb import BrainlessDB, BrainlessBucket
+
+        class DeviceV1(BrainlessBucket):
+            name: str = ""
+            host_override: Optional[str] = None
+
+        db = BrainlessDB(namespace="test")
+        devices = db.collection(DeviceV1)
+        await db.start()
+
+        device = DeviceV1(name="phone1")
+        devices.add(device)
+
+        config = devices._to_config(device)
+        assert "host_override" in config
+        assert config["host_override"] is None
+
+        restored = devices._from_parts(str(device.uuid), config)
+        assert restored.host_override is None
+        assert restored.name == "phone1"
+
+    @pytest.mark.asyncio
+    async def test_none_field_survives_json_round_trip(self):
+        """Optional[str] = None must survive JSON encode/decode cycle."""
+        from typing import Optional
+
+        import msgspec
+
+        from brainlessdb import BrainlessDB, BrainlessBucket
+        from brainlessdb.struct import ConfigWrapper
+
+        class DeviceV1(BrainlessBucket):
+            name: str = ""
+            host_override: Optional[str] = None
+
+        db = BrainlessDB(namespace="test")
+        devices = db.collection(DeviceV1)
+        await db.start()
+
+        device = DeviceV1(name="phone1")
+        devices.add(device)
+
+        # Simulate flush + load cycle
+        config = devices._to_config(device)
+        wrapper = ConfigWrapper.create(config, "test")
+        raw = msgspec.json.encode(wrapper)
+        decoded = msgspec.json.decode(raw, type=ConfigWrapper)
+
+        restored = devices._from_parts(str(device.uuid), decoded.d)
+        assert restored.host_override is None
+        assert restored.name == "phone1"
+
+    @pytest.mark.asyncio
+    async def test_none_field_with_nats_flush_reload(self):
+        """Full flush/reload through mock NATS preserves None fields."""
+        from typing import Optional
+
+        from brainlessdb import BrainlessDB, BrainlessBucket
+        from tests.mock_nats import MockNats
+
+        class DeviceV1(BrainlessBucket):
+            name: str = ""
+            host_override: Optional[str] = None
+
+        nats = MockNats()
+        db = BrainlessDB(nats, namespace="test", flush_interval=0)
+        devices = db.collection(DeviceV1)
+        await db.start()
+
+        device = DeviceV1(name="phone1")
+        devices.add(device)
+        await db.flush()
+        device_uuid = str(device.uuid)
+
+        # Reload from scratch
+        await db.unwatch()
+        devices.clear()
+        devices._loaded = False
+        await devices.load()
+
+        restored = devices.get(device_uuid)
+        assert restored is not None
+        assert restored.name == "phone1"
+        assert restored.host_override is None
+
+        await db.stop()

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/tests/test_deserialization.py

@@ -9,7 +9,7 @@ from typing import Annotated, Optional, Union
 import pytest
 from msgspec import Meta, Struct, field
 
-from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessStruct
+from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessBucket
 from brainlessdb.collection import Collection
 
 
@@ -20,7 +20,7 @@ class LocalData(Struct):
     count: int = 0
 
 
-class EntityWithIntFields(BrainlessStruct):
+class EntityWithIntFields(BrainlessBucket):
     """Entity with various int fields in different buckets."""
 
     # Config field (no flags)
@@ -48,7 +48,7 @@ class EntityWithIntFields(BrainlessStruct):
     _: Optional[LocalData] = None
 
 
-class EntityMixedTypes(BrainlessStruct):
+class EntityMixedTypes(BrainlessBucket):
     """Entity with mixed types to test type preservation."""
 
     int_field: int = 0
@@ -427,14 +427,14 @@ class TestRealWorldUserPattern:
         """Test Optional[Annotated[int, Meta(...)]] pattern like queue_reason."""
         from enum import IntEnum
         import msgspec
-        from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessDBFeat, BrainlessBucket
         from brainlessdb.struct import ConfigWrapper
 
         class Status(IntEnum):
             OFFLINE = 0
             ONLINE = 1
 
-        class UserLike(BrainlessStruct):
+        class UserLike(BrainlessBucket):
             id: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.INDEX})] = 0
             group_id: int = 0
             # Pattern from queue_reason - Optional[Annotated[int, ...]]
@@ -490,14 +490,14 @@ class TestRealWorldUserPattern:
     async def test_nested_struct_pattern(self):
         """Test nested struct like AgentChannelsV1."""
         import msgspec
-        from brainlessdb import BrainlessDB, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessBucket
         from brainlessdb.struct import ConfigWrapper
 
         class Channels(Struct):
             voice: int = 0
             chat: int = 0
 
-        class UserWithChannels(BrainlessStruct):
+        class UserWithChannels(BrainlessBucket):
             id: int = 0
             channels: Channels = field(default_factory=Channels)
 
@@ -526,14 +526,14 @@ class TestRealWorldUserPattern:
     async def test_vcard_list_pattern(self):
         """Test list of nested structs like vcard: list[VCardV1]."""
         import msgspec
-        from brainlessdb import BrainlessDB, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessBucket
         from brainlessdb.struct import ConfigWrapper
 
         class VCard(Struct):
             name: str = ""
             value: str = ""
 
-        class UserWithVCard(BrainlessStruct):
+        class UserWithVCard(BrainlessBucket):
             id: int = 0
             vcard: Optional[list[VCard]] = None
 
@@ -568,7 +568,7 @@ class TestLocalClassDetection:
     @pytest.mark.asyncio
     async def test_optional_annotated_union_pattern(self):
         """Test Optional[Annotated[Union[A, B], Meta()]] pattern from UserV2."""
-        from brainlessdb import BrainlessDB, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessBucket
 
         class AriLocal(Struct):
             counter: int = 0
@@ -576,7 +576,7 @@ class TestLocalClassDetection:
         class UcsLocal(Struct):
             counter: int = 0
 
-        class UserWithUnionLocal(BrainlessStruct):
+        class UserWithUnionLocal(BrainlessBucket):
             id: int = 0
             _: Optional[Annotated[Union[UcsLocal, AriLocal], Meta()]] = None
 
@@ -593,12 +593,12 @@ class TestLocalClassDetection:
     @pytest.mark.asyncio
     async def test_optional_single_class_pattern(self):
         """Test Optional[LocalClass] pattern."""
-        from brainlessdb import BrainlessDB, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessBucket
 
         class TestLocal(Struct):
             value: int = 0
 
-        class UserWithLocal(BrainlessStruct):
+        class UserWithLocal(BrainlessBucket):
             id: int = 0
             _: Optional[TestLocal] = None
 
@@ -609,7 +609,7 @@ class TestLocalClassDetection:
     @pytest.mark.asyncio
     async def test_union_without_optional_pattern(self):
         """Test Union[A, B] (without Optional) pattern."""
-        from brainlessdb import BrainlessDB, BrainlessStruct
+        from brainlessdb import BrainlessDB, BrainlessBucket
 
         class AriData(Struct):
             x: int = 0
@@ -617,7 +617,7 @@ class TestLocalClassDetection:
         class UcsData(Struct):
             x: int = 0
 
-        class UserUnion(BrainlessStruct):
+        class UserUnion(BrainlessBucket):
             id: int = 0
             _: Union[UcsData, AriData] = field(default_factory=UcsData)
 

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/tests/test_fields.py

@@ -4,7 +4,7 @@ from typing import Annotated, Optional, Union
 
 from msgspec import Meta, Struct
 
-from brainlessdb import BrainlessDBFeat, BrainlessStruct
+from brainlessdb import BrainlessDBFeat, BrainlessBucket
 from brainlessdb.fields import analyze_fields
 
 
@@ -17,14 +17,14 @@ class AriV1(Struct):
     channel_id: str = ""
 
 
-class SimpleV1(BrainlessStruct):
+class SimpleV1(BrainlessBucket):
     """Simple struct with no state or app-local."""
 
     id: Annotated[int, Meta()] = 0
     name: Annotated[str, Meta()] = ""
 
 
-class WithStateV1(BrainlessStruct):
+class WithStateV1(BrainlessBucket):
     """Struct with state fields."""
 
     id: Annotated[int, Meta()] = 0
@@ -39,21 +39,21 @@ class WithStateV1(BrainlessStruct):
     ] = 0
 
 
-class WithLocalV1(BrainlessStruct):
+class WithLocalV1(BrainlessBucket):
     """Struct with app-local field."""
 
     id: Annotated[int, Meta()] = 0
     _: Optional[UcsV1] = None
 
 
-class WithUnionLocalV1(BrainlessStruct):
+class WithUnionLocalV1(BrainlessBucket):
     """Struct with Union app-local field."""
 
     id: Annotated[int, Meta()] = 0
     _: Union[UcsV1, AriV1, None] = None
 
 
-class FullV1(BrainlessStruct):
+class FullV1(BrainlessBucket):
     """Struct with config, state, and app-local."""
 
     id: Annotated[int, Meta()] = 0

brainlessdb-0.7.2/tests/test_load_errors.py

@@ -0,0 +1,274 @@
+"""Test graceful error handling during bucket deserialization.
+
+Verifies that corrupt items in buckets are skipped with a logged error
+while valid items still load successfully.
+"""
+
+import logging
+from uuid import uuid1
+
+import msgspec
+import pytest
+
+from brainlessdb import BrainlessDB
+from brainlessdb.struct import ConfigWrapper
+from tests.conftest import UserV1
+from tests.mock_nats import MockNats
+
+
+@pytest.fixture
+def nats():
+    return MockNats()
+
+
+@pytest.fixture
+async def db_and_users(nats):
+    """Create a DB with UserV1 collection connected to mock NATS."""
+    db = BrainlessDB(nats, namespace="test", flush_interval=0)
+    users = db.collection(UserV1)
+    return db, users
+
+
+class TestCorruptConfigBucket:
+    """Test load() skips corrupt entries in config bucket."""
+
+    @pytest.mark.asyncio
+    async def test_corrupt_config_entry_skipped(self, nats, db_and_users, caplog):
+        db, users = db_and_users
+        await db.start()
+
+        # Add a valid user and flush
+        valid = UserV1(id=1, username="alice")
+        users.add(valid)
+        await db.flush()
+        valid_uuid = str(valid.uuid)
+
+        # Stop watch to avoid interference during reload
+        await db.unwatch()
+
+        # Inject corrupt data directly into config bucket
+        js = nats.jetstream()
+        kv = await js.key_value("UserV1")
+        await kv.put("corrupt-uuid-1", b"not valid json {{{")
+
+        # Reload collection
+        users.clear()
+        users._loaded = False
+
+        with caplog.at_level(logging.ERROR, logger="brainlessdb.collection"):
+            count = await users.load()
+
+        assert count == 1
+        assert users.get(valid_uuid) is not None
+        assert users.get("corrupt-uuid-1") is None
+        assert "Failed to decode config for 'corrupt-uuid-1'" in caplog.text
+
+        await db.stop()
+
+    @pytest.mark.asyncio
+    async def test_all_corrupt_config_loads_zero(self, nats, db_and_users, caplog):
+        db, users = db_and_users
+
+        # Inject only corrupt data before start
+        js = nats.jetstream()
+        kv = await js.create_key_value(type("C", (), {"bucket": "UserV1"})())
+        await kv.put("bad-1", b"???")
+        await kv.put("bad-2", b"{invalid")
+
+        with caplog.at_level(logging.ERROR, logger="brainlessdb.collection"):
+            await db.start()
+
+        assert len(users) == 0
+        assert "Failed to decode config" in caplog.text
+
+        await db.stop()
+
+    @pytest.mark.asyncio
+    async def test_valid_entries_survive_alongside_corrupt(self, nats, db_and_users, caplog):
+        db, users = db_and_users
+        await db.start()
+
+        # Flush two valid users
+        u1 = UserV1(id=1, username="alice")
+        u2 = UserV1(id=2, username="bob")
+        users.add(u1)
+        users.add(u2)
+        await db.flush()
+
+        # Stop watch to avoid interference during reload
+        await db.unwatch()
+
+        # Inject corrupt entry
+        js = nats.jetstream()
+        kv = await js.key_value("UserV1")
+        await kv.put("corrupt-1", b"nope")
+
+        # Reload
+        users.clear()
+        users._loaded = False
+        with caplog.at_level(logging.ERROR, logger="brainlessdb.collection"):
+            count = await users.load()
+
+        assert count == 2
+        assert users.find(username="alice") is not None
+        assert users.find(username="bob") is not None
+
+        await db.stop()
+
+
+class TestCorruptStateBucket:
+    """Test load() skips corrupt entries in state bucket."""
+
+    @pytest.mark.asyncio
+    async def test_corrupt_state_entry_skipped(self, nats, caplog):
+        from typing import Annotated
+
+        from msgspec import Meta
+
+        from brainlessdb import BrainlessDBFeat, BrainlessBucket
+
+        class AgentV1(BrainlessBucket):
+            id: int = 0
+            status: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.STATE})] = 0
+
+        db = BrainlessDB(nats, namespace="test", flush_interval=0)
+        agents = db.collection(AgentV1)
+        await db.start()
+
+        # Add valid agent and flush
+        a1 = AgentV1(id=1, status=1)
+        agents.add(a1)
+        await db.flush()
+        a1_uuid = str(a1.uuid)
+
+        # Stop watch to avoid interference
+        await db.unwatch()
+
+        # Inject corrupt state data
+        js = nats.jetstream()
+        kv = await js.key_value("AgentV1-State")
+        await kv.put("corrupt-state-uuid", b"not json!!!")
+
+        # Reload
+        agents.clear()
+        agents._loaded = False
+        with caplog.at_level(logging.ERROR, logger="brainlessdb.collection"):
+            count = await agents.load()
+
+        assert count == 1
+        assert agents.get(a1_uuid) is not None
+        assert "Failed to decode key 'corrupt-state-uuid' from bucket 'AgentV1-State'" in caplog.text
+
+        await db.stop()
+
+
+class TestCorruptLocalBucket:
+    """Test load() skips corrupt entries in local bucket."""
+
+    @pytest.mark.asyncio
+    async def test_corrupt_local_entry_skipped(self, nats, caplog):
+        from typing import Optional
+
+        from msgspec import Struct
+
+        from brainlessdb import BrainlessDB, BrainlessBucket
+
+        class TestLocal(Struct):
+            sid: int = 0
+
+        class ItemV1(BrainlessBucket):
+            id: int = 0
+            _: Optional[TestLocal] = None
+
+        db = BrainlessDB(nats, namespace="test", flush_interval=0)
+        items = db.collection(ItemV1)
+        await db.start()
+
+        # Add valid item
+        i1 = ItemV1(id=1, _=TestLocal(sid=42))
+        items.add(i1)
+        await db.flush()
+
+        # Stop watch to avoid interference
+        await db.unwatch()
+
+        # Inject corrupt local data
+        js = nats.jetstream()
+        kv = await js.key_value("ItemV1-TestLocal")
+        await kv.put("corrupt-local-uuid", b"{{bad}}")
+
+        # Reload
+        items.clear()
+        items._loaded = False
+        with caplog.at_level(logging.ERROR, logger="brainlessdb.collection"):
+            count = await items.load()
+
+        assert count == 1
+        assert items.get(str(i1.uuid)) is not None
+        assert "Failed to decode key 'corrupt-local-uuid' from bucket 'ItemV1-TestLocal'" in caplog.text
+
+        await db.stop()
+
+
+class TestCorruptEntityAssembly:
+    """Test load() skips entities that fail during _from_parts assembly."""
+
+    @pytest.mark.asyncio
+    async def test_invalid_config_data_skipped(self, nats, db_and_users, caplog):
+        """Config data that decodes as JSON but fails struct conversion."""
+        db, users = db_and_users
+
+        js = nats.jetstream()
+        kv = await js.create_key_value(type("C", (), {"bucket": "UserV1"})())
+
+        # Valid ConfigWrapper but with data that will fail msgspec.convert
+        bad_uuid = str(uuid1())
+        bad_wrapper = ConfigWrapper.create({"id": "not-an-int", "username": [1, 2, 3]}, "test")
+        await kv.put(bad_uuid, msgspec.json.encode(bad_wrapper))
+
+        # Valid entry with proper UUID and data
+        good_uuid = str(uuid1())
+        good_wrapper = ConfigWrapper.create({"id": 1, "username": "alice"}, "test")
+        await kv.put(good_uuid, msgspec.json.encode(good_wrapper))
+
+        with caplog.at_level(logging.ERROR, logger="brainlessdb.collection"):
+            await db.start()
+
+        assert len(users) == 1
+        assert users.get(good_uuid) is not None
+        assert users.get(bad_uuid) is None
+        assert f"Failed to build entity '{bad_uuid}'" in caplog.text
+
+        await db.stop()
+
+    @pytest.mark.asyncio
+    async def test_mix_of_all_error_types(self, nats, db_and_users, caplog):
+        """Corrupt config JSON, invalid assembly, and valid entries all together."""
+        db, users = db_and_users
+
+        js = nats.jetstream()
+        kv = await js.create_key_value(type("C", (), {"bucket": "UserV1"})())
+
+        # 1. Corrupt JSON - fails at decode
+        await kv.put("corrupt-json", b"not json")
+
+        # 2. Valid JSON, bad schema - fails at entity assembly
+        bad_uuid = str(uuid1())
+        bad_wrapper = ConfigWrapper.create({"id": [1, 2], "username": {"nested": True}}, "test")
+        await kv.put(bad_uuid, msgspec.json.encode(bad_wrapper))
+
+        # 3. Valid entry
+        good_uuid = str(uuid1())
+        good_wrapper = ConfigWrapper.create({"id": 42, "username": "valid"}, "test")
+        await kv.put(good_uuid, msgspec.json.encode(good_wrapper))
+
+        with caplog.at_level(logging.ERROR, logger="brainlessdb.collection"):
+            await db.start()
+
+        assert len(users) == 1
+        assert users.get(good_uuid) is not None
+        assert users.get(good_uuid).username == "valid"
+        assert "Failed to decode config for 'corrupt-json'" in caplog.text
+        assert f"Failed to build entity '{bad_uuid}'" in caplog.text
+
+        await db.stop()

{brainlessdb-0.6.0 → brainlessdb-0.7.2}/uv.lock

@@ -17,7 +17,7 @@ wheels = [
 
 [[package]]
 name = "brainlessdb"
-version = "0.4.1"
+version = "0.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "msgspec" },