brainlessdb 0.17.4__tar.gz → 1.0.0__tar.gz

brainlessdb-1.0.0/.python-version

@@ -0,0 +1 @@
+3.11

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

@@ -3,6 +3,27 @@
 All notable changes to this project will be documented in this file.
 
 
+## [1.0.0] - 2026-11-03
+
+### 🚀 Features
+
+- Ingest() to store external data with invalid values repaired
+   - add(), update() and save() raise on any invalid value, so one bad column
+from SQL dropped the whole item. Collection.ingest(data, key),
+BrainlessBucket.ingest(data) and BrainlessRegistry.ingest(data) repair
+instead: an invalid value keeps the current one, a new item gets the field
+default, invalid list items and dict entries are removed. Values are
+coerced like msgspec.convert(strict=False).
+
+Repairs are returned (path, action, error) without the invalid value,
+which may be a secret. Struct types are walked directly, so msgspec error
+messages are not parsed. List items are not matched to current ones yet. 
+
+### ⚙️ Miscellaneous Tasks
+
+- [**breaking**] Change minimal required Python version from 3.9 to 3.11
+
+
 ## [0.17.4] - 2026-11-03
 
 ### 🐛 Bug Fixes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: brainlessdb
-Version: 0.17.4
+Version: 1.0.0
 Summary: Typed collections backed by NATS JetStream KV
 Author-email: "INSOFT s.r.o." <helpdesk@insoft.cz>
 License-Expression: MIT
@@ -205,6 +205,35 @@ for item in coll: ...
 item in coll
 ```
 
+## Ingest
+
+For data from outside (SQL rows, config files) that may not match the struct.
+Where `add()`, `update()` and `save()` raise on an invalid value, `ingest()`
+repairs it and reports what it did:
+
+```python
+# add or update item found by a UNIQUE field
+item, repairs = coll.ingest(row, key="id")
+
+# partial update of an item, like update()
+repairs = item.ingest({"vlan": row["vlan"]})
+
+# registry
+repairs = cfg.ingest({"port": "5070"})   # coerced to 5070
+
+for r in repairs:
+    log.warning("%s %s: %s", ".".join(map(str, r.path)), r.action, r.error)
+```
+
+An invalid value keeps the current one (`kept`), or uses the field default on
+a new item (`default`). Invalid list items and dict entries are removed
+(`removed`); list items are not matched to current ones by position. Values
+are coerced like `msgspec.convert(strict=False)`, e.g. `"5070"` to `5070`.
+A repair records the path and error, never the invalid value, which may be a
+password. Data that can't be repaired (an invalid required field of a new
+item) raises `msgspec.ValidationError`, unique violations raise
+`UniqueConstraintError` as usual.
+
 ## Filtering
 
 All filter/find methods are **sync** (operate on in-memory data):

{brainlessdb-0.17.4 → brainlessdb-1.0.0}/README.md

@@ -194,6 +194,35 @@ for item in coll: ...
 item in coll
 ```
 
+## Ingest
+
+For data from outside (SQL rows, config files) that may not match the struct.
+Where `add()`, `update()` and `save()` raise on an invalid value, `ingest()`
+repairs it and reports what it did:
+
+```python
+# add or update item found by a UNIQUE field
+item, repairs = coll.ingest(row, key="id")
+
+# partial update of an item, like update()
+repairs = item.ingest({"vlan": row["vlan"]})
+
+# registry
+repairs = cfg.ingest({"port": "5070"})   # coerced to 5070
+
+for r in repairs:
+    log.warning("%s %s: %s", ".".join(map(str, r.path)), r.action, r.error)
+```
+
+An invalid value keeps the current one (`kept`), or uses the field default on
+a new item (`default`). Invalid list items and dict entries are removed
+(`removed`); list items are not matched to current ones by position. Values
+are coerced like `msgspec.convert(strict=False)`, e.g. `"5070"` to `5070`.
+A repair records the path and error, never the invalid value, which may be a
+password. Data that can't be repaired (an invalid required field of a new
+item) raises `msgspec.ValidationError`, unique violations raise
+`UniqueConstraintError` as usual.
+
 ## Filtering
 
 All filter/find methods are **sync** (operate on in-memory data):

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

@@ -1,12 +1,13 @@
 """Brainless DB - Typed collections backed by NATS JetStream KV."""
 
-__version__ = "0.17.4"
+__version__ = "1.0.0"
 
 from typing import Any, Optional, TypeVar
 
 from .bucket import ShortReadError
 from .client import BrainlessDB
 from .collection import Collection, HasUUID
+from .ingest import IngestResult, Repair
 from .registry import Registry
 from .struct import (
     AppAccessError,
@@ -27,6 +28,8 @@ __all__ = [
     "Collection",
     "Registry",
     "HasUUID",
+    "IngestResult",
+    "Repair",
     "AppAccessError",
     "ShortReadError",
     "UniqueConstraintError",

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

@@ -12,6 +12,7 @@ import msgspec
 
 from .bucket import Bucket
 from .fields import analyze_fields
+from .ingest import IngestResult, repair
 from .struct import (
     BrainlessBucket,
     ConfigWrapper,
@@ -512,6 +513,27 @@ class Collection(Generic[T]):
         self._fire_change(old, obj, local=True)
         return obj
 
+    def ingest(self, data: dict[str, Any], key: str) -> IngestResult:
+        """Add or update item found by unique field `key`, repairing invalid values.
+
+        Update works like item.ingest(): an invalid value keeps the current one.
+        A new item gets the field default instead. Inside lists and dicts the
+        invalid item is removed. Raises msgspec.ValidationError when data can't be
+        repaired, e.g. a new item with invalid required field.
+        """
+        if key not in self._analysis.unique_fields:
+            raise ValueError(f"{self._cls.__name__}.{key} is not a unique field")
+        if key not in data:
+            raise ValueError(f"Missing key field {key!r} in data")
+
+        item = self.find(**{key: data[key]})
+        if item is not None:
+            repairs = item.ingest(data)
+            return IngestResult(self.get(str(item.uuid)), repairs)
+
+        fixed, repairs = repair(data, self._cls)
+        return IngestResult(self.add(fixed), repairs)
+
     def get(self, uuid: str) -> Optional[T]:
         return self._entities.get(uuid)
 

brainlessdb-1.0.0/brainlessdb/ingest.py

@@ -0,0 +1,218 @@
+"""Repair of external data so it fits a struct, for ingest()."""
+
+from typing import Annotated, Any, NamedTuple, Optional, Union, get_args, get_origin
+
+import msgspec
+from msgspec import Struct
+
+Path = tuple[Union[str, int], ...]
+
+_MISSING = object()
+
+
+class Repair(Struct, frozen=True):
+    """One value ingest() could not store as given.
+
+    action is "kept" (current value kept), "default" (field default used) or
+    "removed" (list item or dict entry left out). The invalid value itself is
+    not recorded, it may be a password or key.
+    """
+
+    path: Path
+    action: str
+    error: str
+
+
+class IngestResult(NamedTuple):
+    """Stored item and repairs made to store it."""
+
+    item: Any
+    repairs: list[Repair]
+
+
+class _Unrepairable(Exception):
+    """Value can't be repaired at its level, the level above has to drop it."""
+
+    def __init__(self, error: str) -> None:
+        super().__init__(error)
+        self.error = error
+
+
+def _check(value: Any, tp: Any) -> Optional[str]:
+    """Validation error message, None when value is valid."""
+    try:
+        msgspec.convert(value, tp, strict=False)
+    except msgspec.ValidationError as ex:
+        return str(ex)
+    return None
+
+
+def _unwrap(tp: Any) -> list[Any]:
+    """Candidate types of a hint: Annotated removed, Union split, None left out."""
+    if get_origin(tp) is Annotated:
+        tp = get_args(tp)[0]
+    if get_origin(tp) is Union or type(tp).__name__ == "UnionType":
+        result = []
+        for arg in get_args(tp):
+            result.extend(_unwrap(arg))
+        return result
+    return [] if tp is type(None) else [tp]
+
+
+def _struct_for(candidates: list[Any], value: dict) -> Optional[type]:
+    """Struct type the dict value belongs to, using the tag for tagged unions."""
+    structs = [c for c in candidates if isinstance(c, type) and issubclass(c, Struct)]
+    for cls in structs:
+        config = cls.__struct_config__
+        if config.tag is not None and value.get(config.tag_field) == config.tag:
+            return cls
+    return structs[0] if len(structs) == 1 else None
+
+
+def _repair_value(value: Any, tp: Any, current: Any, path: Path, repairs: list[Repair]) -> Any:
+    """Repaired value, raises _Unrepairable when the value has to be dropped."""
+    error = _check(value, tp)
+    if error is None:
+        return value
+
+    local: list[Repair] = []
+    candidates = _unwrap(tp)
+    fixed: Any = _MISSING
+
+    if isinstance(value, dict):
+        cls = _struct_for(candidates, value)
+        if cls is not None:
+            fixed = _repair_struct(value, cls, current if isinstance(current, dict) else None, path, local)
+        else:
+            dict_type = next((c for c in candidates if get_origin(c) is dict), None)
+            if dict_type is not None:
+                fixed = _repair_dict(value, dict_type, path, local)
+    elif isinstance(value, list):
+        list_type = next((c for c in candidates if _item_type(c) is not None), None)
+        if list_type is not None:
+            fixed = _repair_list(value, _item_type(list_type), path, local)
+
+    if fixed is _MISSING:
+        raise _Unrepairable(error)
+
+    # constraints of the container itself, e.g. min_length, may still fail
+    error = _check(fixed, tp)
+    if error is not None:
+        raise _Unrepairable(error)
+
+    repairs.extend(local)
+    return fixed
+
+
+def _item_type(tp: Any) -> Any:
+    """Item type of list-like type, None for other types."""
+    origin = get_origin(tp)
+    args = get_args(tp)
+    if origin in (list, set, frozenset) and args:
+        return args[0]
+    if origin is tuple and len(args) == 2 and args[1] is Ellipsis:
+        return args[0]
+    return None
+
+
+def _repair_list(value: list, item_type: Any, path: Path, repairs: list[Repair]) -> list:
+    """Invalid items are removed. Items are not matched to current ones, positions may differ."""
+    fixed = []
+    for index, item in enumerate(value):
+        try:
+            fixed.append(_repair_value(item, item_type, None, (*path, index), repairs))
+        except _Unrepairable as ex:
+            repairs.append(Repair((*path, index), "removed", ex.error))
+    return fixed
+
+
+def _repair_dict(value: dict, dict_type: Any, path: Path, repairs: list[Repair]) -> dict:
+    """Entries with invalid key or value are removed."""
+    key_type, value_type = get_args(dict_type)
+    fixed = {}
+    for key, item in value.items():
+        error = _check(key, key_type)
+        if error is not None:
+            repairs.append(Repair((*path, key), "removed", error))
+            continue
+        try:
+            fixed[key] = _repair_value(item, value_type, None, (*path, key), repairs)
+        except _Unrepairable as ex:
+            repairs.append(Repair((*path, key), "removed", ex.error))
+    return fixed
+
+
+def _repair_struct(
+    value: dict,
+    cls: type,
+    current: Optional[dict],
+    path: Path,
+    repairs: list[Repair],
+    *,
+    partial: bool = False,
+) -> dict:
+    """Repair fields of struct dict.
+
+    Invalid field keeps its current value when known, otherwise it is left out so
+    its default is used. Without either the whole struct is unrepairable. With
+    partial=True fields missing in value are not required (update semantics).
+    """
+    fixed = dict(value)
+    local: list[Repair] = []
+    for field in msgspec.structs.fields(cls):
+        key = field.encode_name
+        field_path = (*path, key)
+        known = current.get(key, _MISSING) if current is not None else _MISSING
+
+        if key not in fixed:
+            if partial or not field.required:
+                continue
+            if known is _MISSING:
+                raise _Unrepairable(f"Object missing required field `{key}`")
+            fixed[key] = known
+            local.append(Repair(field_path, "kept", f"Object missing required field `{key}`"))
+            continue
+
+        try:
+            fixed[key] = _repair_value(fixed[key], field.type, known, field_path, local)
+        except _Unrepairable as ex:
+            if known is not _MISSING:
+                fixed[key] = known
+                local.append(Repair(field_path, "kept", ex.error))
+            elif not field.required:
+                del fixed[key]
+                local.append(Repair(field_path, "default", ex.error))
+            else:
+                raise
+
+    repairs.extend(local)
+    return fixed
+
+
+def repair(
+    data: dict[str, Any],
+    cls: type,
+    current: Optional[dict[str, Any]] = None,
+    *,
+    partial: bool = False,
+) -> tuple[dict[str, Any], list[Repair]]:
+    """Make data valid for cls, return it converted to builtins with the repairs made.
+
+    current is the stored item as builtins: invalid values fall back to it, except
+    inside lists and dicts. Values are coerced like msgspec.convert(strict=False),
+    e.g. "5060" to 5060. Raises msgspec.ValidationError when data can't be repaired,
+    e.g. a required field without current value is invalid.
+    """
+    repairs: list[Repair] = []
+    try:
+        fixed = _repair_struct(data, cls, current, (), repairs, partial=partial)
+    except _Unrepairable as ex:
+        raise msgspec.ValidationError(ex.error) from None
+
+    fields = {field.encode_name: field for field in msgspec.structs.fields(cls)}
+    converted = {
+        key: msgspec.to_builtins(msgspec.convert(value, fields[key].type, strict=False))
+        for key, value in fixed.items()
+        if key in fields
+    }
+    return converted, repairs

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

@@ -10,6 +10,8 @@ from weakref import WeakValueDictionary
 import msgspec
 from msgspec import Struct, convert, field, to_builtins
 
+from .ingest import Repair, repair
+
 _VERSION_RE = re.compile(r"^(.+?)V(\d+)$")
 
 
@@ -157,14 +159,7 @@ class BrainlessBucket(Struct, kw_only=True, tag=True, tag_field="TYPE"):
         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 key not in fields:
-                continue
-            current = getattr(self, key)
-            if isinstance(value, dict) and hasattr(current, "__struct_fields__"):
-                value = {**to_builtins(current), **value}
-            merged[key] = to_builtins(value)
+        merged = {**to_builtins(self), **_merge_nested(self, data)}
         new = convert(merged, type(self))
         collection = _registry.get(self._uuid)
         if collection is not None:
@@ -173,6 +168,31 @@ class BrainlessBucket(Struct, kw_only=True, tag=True, tag_field="TYPE"):
             setattr(self, f, getattr(new, f))
         return self
 
+    def ingest(self, data: dict) -> list[Repair]:
+        """Like update(), but repair invalid values instead of raising.
+
+        An invalid value keeps the current one; inside lists and dicts the invalid
+        item is removed (items are not matched by position). Values are coerced,
+        e.g. "5060" to 5060. Returns the repairs made. Raises like update() when
+        data can't be repaired or violates a unique constraint.
+        """
+        fixed, repairs = repair(_merge_nested(self, data), type(self), to_builtins(self), partial=True)
+        self.update(fixed)
+        return repairs
+
+
+def _merge_nested(obj: Struct, data: dict) -> dict:
+    """Builtins of data keys which are fields of obj, dicts merged into nested structs."""
+    result = {}
+    for key, value in data.items():
+        if key not in obj.__struct_fields__:
+            continue
+        current = getattr(obj, key)
+        if isinstance(value, dict) and hasattr(current, "__struct_fields__"):
+            value = {**to_builtins(current), **value}
+        result[key] = to_builtins(value)
+    return result
+
 
 # Fixed namespace for deriving registry storage keys via uuid5.
 _REGISTRY_NS = uuid5(NAMESPACE_DNS, "brainlessdb.registry")
@@ -204,6 +224,20 @@ class BrainlessRegistry(Struct, kw_only=True, tag=True, tag_field="TYPE", dict=T
     def uuid(self) -> UUID:
         return uuid5(_REGISTRY_NS, type(self).__key__)
 
+    def ingest(self, data: dict) -> list[Repair]:
+        """Set fields from data and save, repairing invalid values instead of raising.
+
+        An invalid value keeps the current one. Values are coerced, e.g. "5060"
+        to 5060. Returns the repairs made.
+        """
+        current = to_builtins(self)
+        fixed, repairs = repair(_merge_nested(self, data), type(self), current, partial=True)
+        new = convert({**current, **fixed}, type(self))
+        for f in self.__struct_fields__:
+            setattr(self, f, getattr(new, f))
+        self.save()
+        return repairs
+
     def save(self) -> None:
         """Validate and mark this registry entry dirty in its Registry.
 

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

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

brainlessdb-1.0.0/tests/test_ingest.py

@@ -0,0 +1,175 @@
+"""Test ingest(): storing external data with invalid values repaired."""
+
+from typing import Annotated, Optional, Union
+
+import msgspec
+import pytest
+from msgspec import Meta
+
+from brainlessdb import BrainlessBucket, BrainlessDB, BrainlessDBFeat, BrainlessStruct, Repair
+from tests.conftest import SipConfigV1
+
+
+class PeerV1(BrainlessStruct):
+    port: Annotated[int, Meta(gt=0, lt=65536)] = 5060
+    addr: Optional[str] = None
+
+
+class SpeedDialV1(BrainlessStruct):
+    pos: int
+    number: str
+
+
+class ExtensionLineV1(BrainlessStruct):
+    pos: int
+    peer: PeerV1 = msgspec.field(default_factory=PeerV1)
+
+
+class PhoneV1(BrainlessBucket, kw_only=True):
+    @staticmethod
+    def allows_app(app: str) -> bool:
+        return True
+
+    id: Annotated[int, Meta(extra={"brainlessdb_flags": BrainlessDBFeat.UNIQUE})]
+    name: str
+    mac: Optional[Annotated[str, Meta(pattern="^[0-9A-F]{12}$")]] = None
+    vlan: Annotated[int, Meta(ge=0, lt=4096)] = 0
+    nat: bool = False
+    peer: PeerV1 = msgspec.field(default_factory=PeerV1)
+    lines: list[Union[SpeedDialV1, ExtensionLineV1]] = []
+    data: dict[str, int] = {}
+
+
+@pytest.fixture
+async def phones():
+    db = BrainlessDB(namespace="test")
+    coll = db.collection(PhoneV1)
+    await db.start()
+    return coll
+
+
+def actions(repairs: list[Repair]) -> dict[tuple, str]:
+    return {r.path: r.action for r in repairs}
+
+
+class TestCollectionIngestAdd:
+    @pytest.mark.asyncio
+    async def test_valid_data_has_no_repairs(self, phones):
+        item, repairs = phones.ingest({"id": 1, "name": "a", "vlan": 10}, key="id")
+        assert repairs == []
+        assert item.vlan == 10
+        assert phones.find(id=1) is item
+
+    @pytest.mark.asyncio
+    async def test_invalid_field_gets_default(self, phones):
+        item, repairs = phones.ingest({"id": 1, "name": "a", "mac": "nope", "vlan": 5000}, key="id")
+        assert item.mac is None
+        assert item.vlan == 0
+        assert actions(repairs) == {("mac",): "default", ("vlan",): "default"}
+
+    @pytest.mark.asyncio
+    async def test_values_are_coerced(self, phones):
+        item, repairs = phones.ingest({"id": "1", "name": "a", "vlan": "10", "nat": "true"}, key="id")
+        assert (item.id, item.vlan, item.nat) == (1, 10, True)
+        assert repairs == []
+
+    @pytest.mark.asyncio
+    async def test_invalid_list_item_is_removed(self, phones):
+        lines = [
+            {"TYPE": "SpeedDialV1", "pos": 0, "number": "100"},
+            {"TYPE": "SpeedDialV1", "pos": 1},  # missing required number
+            {"TYPE": "ExtensionLineV1", "pos": 2, "peer": {"port": 0}},
+        ]
+        item, repairs = phones.ingest({"id": 1, "name": "a", "lines": lines}, key="id")
+        assert [line.pos for line in item.lines] == [0, 2]
+        assert item.lines[1].peer.port == 5060
+        assert actions(repairs) == {("lines", 1): "removed", ("lines", 2, "peer", "port"): "default"}
+
+    @pytest.mark.asyncio
+    async def test_invalid_dict_entry_is_removed(self, phones):
+        item, repairs = phones.ingest({"id": 1, "name": "a", "data": {"a": 1, "b": "x"}}, key="id")
+        assert item.data == {"a": 1}
+        assert actions(repairs) == {("data", "b"): "removed"}
+
+    @pytest.mark.asyncio
+    async def test_invalid_required_field_raises(self, phones):
+        with pytest.raises(msgspec.ValidationError):
+            phones.ingest({"id": 1, "name": None}, key="id")
+        assert len(phones) == 0
+
+    @pytest.mark.asyncio
+    async def test_repair_does_not_record_value(self, phones):
+        _, repairs = phones.ingest({"id": 1, "name": "a", "mac": "secret-value"}, key="id")
+        assert "secret-value" not in repr(repairs)
+
+    @pytest.mark.asyncio
+    async def test_input_is_not_mutated(self, phones):
+        data = {"id": 1, "name": "a", "mac": "nope", "lines": [{"TYPE": "SpeedDialV1", "pos": 1}]}
+        phones.ingest(data, key="id")
+        assert data == {"id": 1, "name": "a", "mac": "nope", "lines": [{"TYPE": "SpeedDialV1", "pos": 1}]}
+
+
+class TestCollectionIngestUpdate:
+    @pytest.mark.asyncio
+    async def test_invalid_field_keeps_current(self, phones):
+        phones.ingest({"id": 1, "name": "a", "vlan": 10, "mac": "AABBCCDDEEFF"}, key="id")
+        item, repairs = phones.ingest({"id": 1, "name": None, "vlan": "x", "nat": True}, key="id")
+        assert (item.name, item.vlan, item.nat, item.mac) == ("a", 10, True, "AABBCCDDEEFF")
+        assert actions(repairs) == {("name",): "kept", ("vlan",): "kept"}
+
+    @pytest.mark.asyncio
+    async def test_nested_struct_keeps_current(self, phones):
+        phones.ingest({"id": 1, "name": "a", "peer": {"port": 5070, "addr": "10.0.0.1"}}, key="id")
+        item, repairs = phones.ingest({"id": 1, "peer": {"port": -1, "addr": "10.0.0.2"}}, key="id")
+        assert (item.peer.port, item.peer.addr) == (5070, "10.0.0.2")
+        assert actions(repairs) == {("peer", "port"): "kept"}
+
+    @pytest.mark.asyncio
+    async def test_returns_stored_item(self, phones):
+        phones.ingest({"id": 1, "name": "a"}, key="id")
+        item, _ = phones.ingest({"id": 1, "name": "b"}, key="id")
+        assert item is phones.find(id=1)
+        assert item.name == "b"
+
+    @pytest.mark.asyncio
+    async def test_key_must_be_unique_field(self, phones):
+        with pytest.raises(ValueError, match="unique"):
+            phones.ingest({"id": 1, "name": "a"}, key="name")
+
+
+class TestItemIngest:
+    @pytest.mark.asyncio
+    async def test_partial_update_keeps_other_fields(self, phones):
+        item, _ = phones.ingest({"id": 1, "name": "a", "vlan": 10}, key="id")
+        repairs = item.ingest({"nat": True, "vlan": 99999})
+        stored = phones.find(id=1)
+        assert (stored.name, stored.vlan, stored.nat) == ("a", 10, True)
+        assert actions(repairs) == {("vlan",): "kept"}
+
+    @pytest.mark.asyncio
+    async def test_ignores_unknown_keys(self, phones):
+        item, _ = phones.ingest({"id": 1, "name": "a"}, key="id")
+        assert item.ingest({"unknown": 1}) == []
+
+
+class TestRegistryIngest:
+    @pytest.mark.asyncio
+    async def test_invalid_value_keeps_current(self):
+        db = BrainlessDB(namespace="test")
+        sip = db.registry(SipConfigV1)
+        await db.start()
+
+        repairs = sip.ingest({"host": None, "port": "5070"})
+        assert (sip.host, sip.port) == ("127.0.0.1", 5070)
+        assert actions(repairs) == {("host",): "kept"}
+        await db.stop()
+
+    @pytest.mark.asyncio
+    async def test_marks_dirty(self):
+        db = BrainlessDB(namespace="test")
+        sip = db.registry(SipConfigV1)
+        await db.start()
+
+        sip.ingest({"port": 5070})
+        assert db._registries["sipconfigv1"]._dirty
+        await db.stop()

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

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

brainlessdb-0.17.4/.python-version

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