flet 0.70.0.dev5776__py3-none-any.whl → 0.70.0.dev6145__py3-none-any.whl

flet/controls/object_patch.py

@@ -30,11 +30,16 @@
 #
 
 import dataclasses
+import logging
 import weakref
 from enum import Enum
+from typing import Any, Optional
 
 from flet.controls.keys import Key
 
+logger = logging.getLogger("flet_object_patch")
+logger.setLevel(logging.INFO)
+
 _ST_ADD = 0
 _ST_REMOVE = 1
 
@@ -228,13 +233,16 @@ class ObjectPatch:
         src,
         dst,
         control_cls,
+        parent: Any = None,
+        path: Optional[list[Any]] = None,
+        frozen: bool = False,
     ):
         builder = DiffBuilder(
             src,
             dst,
             control_cls=control_cls,
         )
-        builder._compare_values(None, [], None, src, dst, False)
+        builder._compare_values(parent, path or [], None, src, dst, frozen=frozen)
 
         ops = list(builder.execute())
         added = list(builder.get_added_controls())
@@ -429,119 +437,155 @@ class DiffBuilder:
             yield curr[2].operation
             curr = curr[1]
 
+    def _index_key(self, item, item_key, path):
+        """
+        Return the composite key used to pair add/remove
+        (by control key if present).
+        """
+        return item_key if item_key is not None else item
+
+    def _maybe_compare_dataclasses(self, parent, path, src, dst, frozen):
+        """
+        Compare dataclasses only when both are dataclasses and
+        identity/"frozen" rules allow it.
+        """
+        if (
+            dataclasses.is_dataclass(src)
+            and dataclasses.is_dataclass(dst)
+            and ((not frozen and src is dst) or (frozen and src is not dst))
+        ):
+            self._compare_dataclasses(parent, path, src, dst, frozen)
+
+    def _affected_is_list(self, op):
+        """
+        Return True if the item the op affects lives in a list in the destination doc.
+        We must not rely on op.key’s type because PatchOperation coerces to int.
+        """
+        container = op.to_last(self.dst_doc)
+        return isinstance(container, list)
+
+    def _emit_move(self, from_loc, to_loc):
+        """Create and insert a move operation."""
+        self.insert(MoveOperation({"op": "move", "from": from_loc, "path": to_loc}))
+
     def _item_added(self, parent, path, key, item, item_key=None, frozen=False):
-        # print("\n\n_item_added:", path, key, item, item_key)
-        index_key = item_key if item_key is not None else item
-        index = self.take_index(index_key, _ST_REMOVE)
-        if index is not None:
-            op = index[2]
-            # print("\n\n_ST_REMOVE:", op.__dict__, item)
-
-            # compare moved item
-            src = op.operation["value"]
+        logger.debug(
+            f"_item_added: path={path} key={key} item={item} item_key={item_key}"
+        )
+
+        index_key = self._index_key(item, item_key, path)
+        paired_idx = self.take_index(index_key, _ST_REMOVE)
+
+        # A matching 'remove' exists: it's a move (or an in-place update)
+        if paired_idx is not None:
+            rem_op: RemoveOperation = paired_idx[2]  # the earlier remove
+            src = rem_op.operation["value"]
             dst = item
 
+            # undo bookkeeping for the removed dataclass (it’s coming back)
             self._undo_dataclass_removed(src)
 
-            if (
-                dataclasses.is_dataclass(src)
-                and dataclasses.is_dataclass(dst)
-                and ((not frozen and src is dst) or (frozen and src is not dst))
-            ):
-                self._compare_dataclasses(
-                    src.parent,
-                    _path_join(path, key),
-                    src,
-                    dst,
-                    frozen,
-                )
+            # If the affected sequence is a list, adjust later op indices after removal
+            if isinstance(rem_op.key, int) and isinstance(key, int):
+                for v in self.iter_from(paired_idx):
+                    rem_op.key = v._on_undo_remove(rem_op.path, rem_op.key)
+
+            # Drop the paired remove from the chain: we’re going to emit either
+            # compares or a move
+            self.remove(paired_idx)
+
+            src_loc = rem_op.location
+            dst_loc = _path_join(path, key)
+
+            # Compare first (for dataclasses), anchored at source or dest depending
+            # on whether we move
+            if src_loc != dst_loc:
+                # Compare on the source location before we move (matches your tests’
+                # expectations)
+                self._maybe_compare_dataclasses(parent, src_loc, src, dst, frozen)
+                # Then emit the move
+                self._emit_move(src_loc, dst_loc)
+                return
+            else:
+                # No move, just in-place updates
+                self._maybe_compare_dataclasses(parent, dst_loc, src, dst, frozen)
+                return
 
-            if isinstance(op.key, int) and isinstance(key, int):
-                for v in self.iter_from(index):
-                    op.key = v._on_undo_remove(op.path, op.key)
-
-            self.remove(index)
-            if op.location != _path_join(path, key):
-                new_op = MoveOperation(
-                    {
-                        "op": "move",
-                        "from": op.location,
-                        "path": _path_join(path, key),
-                    }
-                )
-                self.insert(new_op)
-        else:
-            new_op = AddOperation(
-                {
-                    "op": "add",
-                    "path": _path_join(path, key),
-                    "value": item,
-                }
-            )
-            new_index = self.insert(new_op)
-            self.store_index(index_key, new_index, _ST_ADD)
-            self._dataclass_added(item, parent, frozen)
+        # No matching remove: this is a plain add
+        add_op = AddOperation(
+            {"op": "add", "path": _path_join(path, key), "value": item}
+        )
+        add_idx = self.insert(add_op)
+        self.store_index(index_key, add_idx, _ST_ADD)
+        self._dataclass_added(item, parent, frozen)
 
     def _item_removed(self, path, key, item, item_key=None, frozen=False):
-        # print("\n\n_item_removed:", path, key, item, item_key)
-        new_op = RemoveOperation(
+        logger.debug(
+            f"_item_removed: path={path} key={key} item={item} item_key={item_key}"
+        )
+
+        index_key = self._index_key(item, item_key, path)
+        rem_op = RemoveOperation(
             {"op": "remove", "path": _path_join(path, key), "value": item}
         )
-        index_key = item_key if item_key is not None else item
-        index = self.take_index(index_key, _ST_ADD)
-        new_index = self.insert(new_op)
-        if index is not None:
-            op = index[2]
-            # print("\n\n_ST_ADD:", op.__dict__)
-
-            # compare moved item
+        rem_idx = self.insert(rem_op)
+
+        paired_idx = self.take_index(index_key, _ST_ADD)
+
+        # A matching 'add' exists: it's a move (or an in-place update)
+        if paired_idx is not None:
+            add_op: AddOperation = paired_idx[2]  # the earlier add
             src = item
-            dst = op.operation["value"]
+            dst = add_op.operation["value"]
 
+            # undo bookkeeping for the added dataclass (it’s being consumed by the move)
             self._undo_dataclass_added(dst)
 
-            if (
-                dataclasses.is_dataclass(src)
-                and dataclasses.is_dataclass(dst)
-                and ((not frozen and src is dst) or (frozen and src is not dst))
-            ):
-                self._compare_dataclasses(
-                    dst.parent,
-                    _path_join(op.path, op.key),
+            # If the added op affects a list, adjust later ops after that add
+            if self._affected_is_list(add_op):
+                for v in self.iter_from(paired_idx):
+                    add_op.key = v._on_undo_add(add_op.path, add_op.key)
+
+            src_loc = rem_op.location
+            dst_loc = add_op.location
+
+            # The earlier add no longer stands on its own
+            self.remove(paired_idx)
+
+            if src_loc != dst_loc:
+                # If we’re moving, compare anchored at the source BEFORE the move
+                # (matches your tests)
+                self._maybe_compare_dataclasses(
+                    dst.parent if hasattr(dst, "parent") else None,
+                    src_loc,
                     src,
                     dst,
                     frozen,
                 )
-
-            # We can't rely on the op.key type since PatchOperation casts
-            # the .key property to int and this path wrongly ends up being taken
-            # for numeric string dict keys while the intention is to only handle lists.
-            # So we do an explicit check on the item affected by the op instead.
-            added_item = op.to_last(self.dst_doc)
-            if isinstance(added_item, list):
-                for v in self.iter_from(index):
-                    op.key = v._on_undo_add(op.path, op.key)
-
-            self.remove(index)
-            if new_op.location != op.location:
-                new_op = MoveOperation(
-                    {
-                        "op": "move",
-                        "from": new_op.location,
-                        "path": op.location,
-                    }
+                # Turn the just-inserted remove into a move (reuse node)
+                rem_idx[2] = MoveOperation(
+                    {"op": "move", "from": src_loc, "path": dst_loc}
                 )
-                new_index[2] = new_op
-
+                return
             else:
-                self.remove(new_index)
+                # No move after all; drop the remove from the chain (pair consumed)
+                self.remove(rem_idx)
+                # In-place updates only
+                self._maybe_compare_dataclasses(
+                    dst.parent if hasattr(dst, "parent") else None,
+                    _path_join(add_op.path, add_op.key),
+                    src,
+                    dst,
+                    frozen,
+                )
+                return
 
-        else:
-            self.store_index(index_key, new_index, _ST_REMOVE)
-            self._dataclass_removed(item)
+        # No matching add: keep the remove and remember this dataclass
+        self.store_index(index_key, rem_idx, _ST_REMOVE)
+        self._dataclass_removed(item)
 
     def _item_replaced(self, path, key, item):
-        # print("_item_replaced:", path, key, item, frozen)
+        logger.debug("_item_replaced: %s %s %s:", path, key, item)
         self.insert(
             ReplaceOperation(
                 {
@@ -553,7 +597,7 @@ class DiffBuilder:
         )
 
     def _compare_dicts(self, parent, path, src, dst, frozen):
-        # print("\n_compare_dicts:", path, src, dst)
+        logger.debug("\n_compare_dicts: %s %s %s", path, src, dst)
 
         src_keys = set(src.keys())
         dst_keys = set(dst.keys())
@@ -570,106 +614,246 @@ class DiffBuilder:
             self._compare_values(parent, path, key, src[key], dst[key], frozen)
 
     def _compare_lists(self, parent, path, src, dst, frozen):
-        # print("\n_compare_lists:", path, src, dst)
+        logger.debug(f"\n_compare_lists: {path} {src} {dst}")
 
-        len_src, len_dst = len(src), len(dst)
-        max_len = max(len_src, len_dst)
-        min_len = min(len_src, len_dst)
-        for key in range(max_len):
-            if key < min_len:
-                old, new = src[key], dst[key]
-                # print("\n\nCOMPARE LIST ITEM:", key, "\n\nOLD:", old, "\n\nNEW:", new)
+        # ----- helper: get keys quickly -----
+        def k(obj):
+            return get_control_key(obj)
 
-                if isinstance(old, dict) and isinstance(new, dict):
-                    self._compare_dicts(parent, _path_join(path, key), old, new, frozen)
-
-                elif isinstance(old, list) and isinstance(new, list):
-                    self._compare_lists(parent, _path_join(path, key), old, new, frozen)
+        src_keys = [k(item) for item in src]
+        dst_keys = [k(item) for item in dst]
 
-                elif dataclasses.is_dataclass(old) and dataclasses.is_dataclass(new):
-                    frozen = (
-                        (old is not None and hasattr(old, "_frozen"))
-                        or (new is not None and hasattr(new, "_frozen"))
-                        or frozen
+        # Use keyed algorithm only when every element provides a key on both sides
+        all_keyed = (
+            src_keys
+            and dst_keys
+            and all(key is not None for key in src_keys)
+            and all(key is not None for key in dst_keys)
+        )
+        # print("list info", path, len(src_keys), len(dst_keys), all_keyed)
+        if not all_keyed:
+            # fall back to your existing element-wise logic
+            len_src, len_dst = len(src), len(dst)
+            max_len = max(len_src, len_dst)
+            min_len = min(len_src, len_dst)
+            for key in range(max_len):
+                if key < min_len:
+                    old, new = src[key], dst[key]
+                    logger.debug(
+                        f"\n\nCOMPARE LIST ITEM: {key}\n\nOLD: {old}\n\nNEW: {new}"
                     )
 
-                    old_control_key = get_control_key(old)
-                    new_control_key = get_control_key(new)
-
-                    if (not frozen and old is new) or (
-                        frozen
-                        and old is not new  # not a cached control tree
-                        and type(old) is type(new)  # iteams are of the same type
-                        and (
-                            old_control_key is None
-                            or new_control_key is None
-                            or old_control_key == new_control_key
-                        )  # same list key or both None
-                    ):
-                        # print("\n\ncompare list dataclasses:", new)
-                        self._compare_dataclasses(
+                    if isinstance(old, dict) and isinstance(new, dict):
+                        self._compare_dicts(
                             parent, _path_join(path, key), old, new, frozen
                         )
-                    elif (not frozen and old is not new) or (frozen and old is not new):
-                        # print(
-                        #     "\n\ndataclass removed and added:",
-                        #     "\n\nOLD:",
-                        #     old,
-                        #     "\n\nNEW:",
-                        #     new,
-                        # )
-                        self._item_removed(
-                            path,
-                            key,
-                            old,
-                            item_key=(old_control_key, path)
-                            if old_control_key is not None
-                            else old,
-                            frozen=frozen,
+
+                    elif isinstance(old, list) and isinstance(new, list):
+                        self._compare_lists(
+                            parent, _path_join(path, key), old, new, frozen
                         )
-                        self._item_added(
-                            parent,
-                            path,
-                            key,
-                            new,
-                            item_key=(new_control_key, path)
-                            if new_control_key is not None
-                            else new,
-                            frozen=frozen,
+
+                    elif dataclasses.is_dataclass(old) and dataclasses.is_dataclass(
+                        new
+                    ):
+                        frozen_local = (
+                            (old is not None and hasattr(old, "_frozen"))
+                            or (new is not None and hasattr(new, "_frozen"))
+                            or frozen
                         )
+                        old_control_key = k(old)
+                        new_control_key = k(new)
+                        if (not frozen_local and old is new) or (
+                            frozen_local
+                            and old is not new
+                            and type(old) is type(new)
+                            and (
+                                old_control_key is None
+                                or new_control_key is None
+                                or old_control_key == new_control_key
+                            )
+                        ):
+                            self._compare_dataclasses(
+                                parent, _path_join(path, key), old, new, frozen_local
+                            )
+                        else:
+                            self._item_removed(path, key, old, frozen=frozen)
+                            self._item_added(parent, path, key, new, frozen=frozen)
+
+                    elif type(old) is not type(new) or old != new:
+                        self._item_removed(path, key, old, frozen=frozen)
+                        self._item_added(parent, path, key, new, frozen=frozen)
+
+                elif len_src > len_dst:
+                    control_key = k(src[key])
+                    self._item_removed(
+                        path,
+                        len_dst,
+                        src[key],
+                        item_key=(control_key, path)
+                        if control_key is not None
+                        else src[key],
+                        frozen=frozen,
+                    )
+                else:
+                    control_key = k(dst[key])
+                    self._item_added(
+                        parent,
+                        path,
+                        key,
+                        dst[key],
+                        item_key=(control_key, path)
+                        if control_key is not None
+                        else dst[key],
+                        frozen=frozen,
+                    )
+            return
 
+        if src_keys == dst_keys:
+            # print("keyed fast path", path, len(src))
+            # Keys are identical and in the same order: treat as positional diff
+            for idx, (old, new) in enumerate(zip(src, dst)):
+                if isinstance(old, dict) and isinstance(new, dict):
+                    self._compare_dicts(parent, _path_join(path, idx), old, new, frozen)
+                elif isinstance(old, list) and isinstance(new, list):
+                    self._compare_lists(parent, _path_join(path, idx), old, new, frozen)
+                elif dataclasses.is_dataclass(old) and dataclasses.is_dataclass(new):
+                    self._compare_dataclasses(
+                        parent, _path_join(path, idx), old, new, frozen
+                    )
                 elif type(old) is not type(new) or old != new:
-                    # print("removed and added:", old, new)
-                    self._item_removed(path, key, old, frozen=frozen)
-                    self._item_added(parent, path, key, new, frozen=frozen)
-
-            elif len_src > len_dst:
-                control_key = get_control_key(src[key])
-                self._item_removed(
-                    path,
-                    len_dst,
-                    src[key],
-                    item_key=(control_key, path)
-                    if control_key is not None
-                    else src[key],
-                    frozen=frozen,
+                    self._item_replaced(path, idx, new)
+            return
+
+        # -------- Keyed, React-style reconciliation --------
+        # We’ll mutate a working copy of the old list so emitted indices are “live”.
+        work = list(src)
+        work_keys = src_keys[:]
+        # Map key -> current index in `work`
+        pos = {key: i for i, key in enumerate(work_keys)}
+        dst_keys = dst_keys  # renamed for clarity
+        new_index_by_key = {key: i for i, key in enumerate(dst_keys)}
+        new_keys_set = set(new_index_by_key.keys())
+
+        def _reindex(start_idx: int) -> None:
+            for j in range(start_idx, len(work_keys)):
+                pos[work_keys[j]] = j
+
+        def _remove_from_work(idx: int):
+            removed_item = work.pop(idx)
+            removed_key = work_keys.pop(idx)
+            pos.pop(removed_key, None)
+            if idx < len(work_keys):
+                _reindex(idx)
+            return removed_item, removed_key
+
+        def _insert_into_work(idx: int, item, key):
+            work.insert(idx, item)
+            work_keys.insert(idx, key)
+            pos[key] = idx
+            if idx + 1 <= len(work_keys):
+                _reindex(idx + 1)
+
+        def emit_replace_at(idx, old_item, new_item):
+            # For dataclasses we delegate to your existing field diff.
+            if (
+                dataclasses.is_dataclass(old_item)
+                and dataclasses.is_dataclass(new_item)
+                and old_item is not new_item
+            ):
+                # Force field-wise compare even if different instances:
+                self._compare_dataclasses(
+                    parent, _path_join(path, idx), old_item, new_item, True
                 )
+            elif type(old_item) is not type(new_item) or old_item != new_item:
+                self._item_replaced(path, idx, new_item)
+
+        # Scan forward through desired new order.
+        i = 0
+        while i < len(dst):
+            target_key = dst_keys[i]
+
+            # First, delete any items currently at position i that should NOT be here:
+            # - keys that don't exist anymore
+            # - or keys that exist but must appear BEFORE i in the new order
+            #   (they are out of place here)
+            while i < len(work):
+                cur_key = work_keys[i]
+                if cur_key not in new_keys_set:
+                    # remove disappearing item at i
+                    self._item_removed(
+                        path, i, work[i], item_key=(cur_key, path), frozen=True
+                    )
+                    _remove_from_work(i)
+                    continue
+                desired_pos = new_index_by_key[cur_key]
+                if desired_pos < i:
+                    # this item belongs earlier; it should have already been moved
+                    # before.
+                    # remove it here; it will be re-inserted (moved) where needed.
+                    self._item_removed(
+                        path, i, work[i], item_key=(cur_key, path), frozen=True
+                    )
+                    _remove_from_work(i)
+                    continue
+                break  # current slot is ok to fill with target
+
+            if target_key in pos:
+                cur_idx = pos[target_key]
+                old_item = work[cur_idx]
+                new_item = dst[i]
+
+                if cur_idx == i:
+                    # in place: just emit updates
+                    emit_replace_at(i, old_item, new_item)
+                else:
+                    # move from cur_idx -> i
+                    # Emit updates anchored at SOURCE (cur_idx) before the move
+                    # (matches your tests)
+                    emit_replace_at(cur_idx, old_item, new_item)
+
+                    # Emit move
+                    move_op = MoveOperation(
+                        {
+                            "op": "move",
+                            "from": _path_join(path, cur_idx),
+                            "path": _path_join(path, i),
+                        }
+                    )
+                    self.insert(move_op)
 
+                    # Apply the move in our working model
+                    moved_item, _ = _remove_from_work(cur_idx)
+                    insert_idx = i if cur_idx >= i else i
+                    _insert_into_work(insert_idx, moved_item, target_key)
             else:
-                control_key = get_control_key(dst[key])
+                # brand-new key: add at i
                 self._item_added(
                     parent,
                     path,
-                    key,
-                    dst[key],
-                    item_key=(control_key, path)
-                    if control_key is not None
-                    else dst[key],
-                    frozen=frozen,
+                    i,
+                    dst[i],
+                    item_key=(target_key, path),
+                    frozen=True,
                 )
+                _insert_into_work(i, dst[i], target_key)
+
+            i += 1
+
+        # Finally, remove any trailing leftovers (present in old but not in new)
+        # We remove from the end so indices stay valid.
+        j = len(work) - 1
+        while j >= 0:
+            key_j = work_keys[j]
+            if key_j not in new_keys_set:
+                self._item_removed(
+                    path, j, work[j], item_key=(key_j, path), frozen=True
+                )
+                _remove_from_work(j)
+            j -= 1
 
     def _compare_dataclasses(self, parent, path, src, dst, frozen):
-        # print("\n_compare_dataclasses:", path, src, dst, frozen)
+        logger.debug(f"\n_compare_dataclasses: {path} \n\n{src}\n{dst}\n")
 
         if (
             self.control_cls
@@ -681,18 +865,16 @@ class DiffBuilder:
 
         if self.control_cls and isinstance(dst, self.control_cls):
             if frozen and hasattr(src, "_i"):
-                dst._i = src._i
+                dst._migrate_state(src)
                 if not hasattr(dst, "_initialized"):
                     orig_frozen = getattr(dst, "_frozen", None)
                     if orig_frozen is not None:
                         del dst._frozen
                     dst.build()
-                    dst.before_update()
                     if orig_frozen is not None:
                         object.__setattr__(dst, "_frozen", orig_frozen)
                     object.__setattr__(dst, "_initialized", True)
-            elif not frozen:
-                dst.before_update()
+            dst._before_update_safe()
 
         if not frozen:
             # in-place comparison
@@ -708,10 +890,17 @@ class DiffBuilder:
                     old = change[0]
                     new = change[1]
 
-                    # print("_compare_values:changes", old, new)
+                    logger.debug("\n\n_compare_values:changes %s %s", old, new)
 
                     self._compare_values(dst, path, field_name, old, new, frozen)
 
+                    if field_name in prev_lists:
+                        del prev_lists[field_name]
+                    if field_name in prev_dicts:
+                        del prev_dicts[field_name]
+                    if field_name in prev_classes:
+                        del prev_classes[field_name]
+
                     # update prev value
                     if isinstance(new, list):
                         new = new[:]
@@ -729,8 +918,11 @@ class DiffBuilder:
                         del prev_lists[field_name]
                     continue
                 new = getattr(dst, field_name)
+                if not isinstance(new, list):
+                    del prev_lists[field_name]
+                else:
+                    prev_lists[field_name] = new[:]
                 self._compare_values(dst, path, field_name, old, new, frozen)
-                prev_lists[field_name] = new[:]
 
             # compare dicts
             for field_name, old in list(prev_dicts.items()):
@@ -739,8 +931,11 @@ class DiffBuilder:
                         del prev_dicts[field_name]
                     continue
                 new = getattr(dst, field_name)
+                if not isinstance(new, dict):
+                    del prev_dicts[field_name]
+                else:
+                    prev_dicts[field_name] = new.copy()
                 self._compare_values(dst, path, field_name, old, new, frozen)
-                prev_dicts[field_name] = new.copy()
 
             # compare dataclasses
             for field_name, old in list(prev_classes.items()):
@@ -749,20 +944,21 @@ class DiffBuilder:
                         del prev_classes[field_name]
                     continue
                 new = getattr(dst, field_name)
+                if not dataclasses.is_dataclass(new):
+                    del prev_classes[field_name]
+                else:
+                    prev_classes[field_name] = new
                 self._compare_values(dst, path, field_name, old, new, frozen)
-                prev_classes[field_name] = new
 
             changes.clear()
         else:
             # frozen comparison
-            # print(
-            #     "\nfrozen dataclass compare:",
-            #     src,
-            #     "\n\ndst:",
-            #     dst,
-            #     "\n\nparent:",
-            #     parent,
-            # )
+            logger.debug(
+                "\nfrozen dataclass compare:%s\n\n    dst:%s\n\n    parent:%s",
+                src,
+                dst,
+                parent,
+            )
             for field in dataclasses.fields(dst):
                 if "skip" not in field.metadata:
                     old = getattr(src, field.name)
@@ -775,7 +971,14 @@ class DiffBuilder:
             self._dataclass_added(dst, parent, frozen)
 
     def _compare_values(self, parent, path, key, src, dst, frozen):
-        # print("\n_compare_values:", path, key, src, dst, frozen)
+        logger.debug(
+            "\n_compare_values: %s %s (Frozen: %s)\n\n%s\n%s\n",
+            path,
+            key,
+            frozen,
+            src,
+            dst,
+        )
 
         if isinstance(src, dict) and isinstance(dst, dict):
             self._compare_dicts(parent, _path_join(path, key), src, dst, frozen)
@@ -795,7 +998,9 @@ class DiffBuilder:
                 or frozen
             )
 
-            # print("\n_compare_values:dataclasses", src, dst, frozen)
+            logger.debug(
+                "\n_compare_values:dataclasses (Frozen: %s) %s %s", frozen, src, dst
+            )
 
             if (not frozen and src is dst) or (
                 frozen and src is not dst and type(src) is type(dst)
@@ -811,20 +1016,50 @@ class DiffBuilder:
                 self._dataclass_added(dst, parent, frozen)
 
         elif type(src) is not type(dst) or src != dst:
+            logger.debug(
+                "\n_compare_values:replaced %s %s %s\n\n%s %s",
+                path,
+                key,
+                src,
+                dst,
+                frozen,
+            )
             self._item_replaced(path, key, dst)
             self._dataclass_removed(src)
             self._dataclass_added(dst, parent, frozen)
 
+            if not frozen:
+                prev_lists = getattr(dst, "__prev_lists", {})
+                prev_dicts = getattr(dst, "__prev_dicts", {})
+                prev_classes = getattr(dst, "__prev_classes", {})
+
+                if isinstance(src, list) and key in prev_lists:
+                    del prev_lists[key]
+                if isinstance(src, dict) and key in prev_dicts:
+                    del prev_dicts[key]
+                if dataclasses.is_dataclass(src) and key in prev_classes:
+                    del prev_classes[key]
+                if isinstance(dst, list) and key is not None:
+                    prev_lists[key] = dst[:]
+                if isinstance(dst, dict) and key is not None:
+                    prev_dicts[key] = dst.copy()
+                if dataclasses.is_dataclass(dst) and key is not None:
+                    prev_classes[key] = dst
+
     def _dataclass_added(self, item, parent, frozen):
+        logger.debug("\n\nDataclass added: %s %s %s", item, parent, frozen)
         if dataclasses.is_dataclass(item):
             if parent:
+                logger.debug("\n\nAdding parent %s to item: %s", parent, item)
                 if parent is item:
                     raise Exception(f"Parent is the same as item: {item}")
                 item._parent = weakref.ref(parent)
+            else:
+                logger.debug("\n\nSkip adding parent to item: %s", item)
             if frozen:
                 item._frozen = frozen
 
-            # print("\n_dataclass_added:", self._get_dataclass_key(item))
+            logger.debug("\n_dataclass_added: %s", self._get_dataclass_key(item))
             self._added_dataclasses[self._get_dataclass_key(item)] = item
 
         elif isinstance(item, dict):
@@ -836,12 +1071,11 @@ class DiffBuilder:
                 self._dataclass_added(v, parent, frozen)
 
     def _undo_dataclass_added(self, item):
-        # print("\n_undo_dataclass_added:", self._get_dataclass_key(item))
         self._added_dataclasses.pop(self._get_dataclass_key(item), None)
 
     def _dataclass_removed(self, item):
+        logger.debug("\n\nDataclass removed: %s", item)
         if dataclasses.is_dataclass(item):
-            # print("\n_dataclass_removed:", self._get_dataclass_key(item))
             self._removed_dataclasses[self._get_dataclass_key(item)] = item
 
         elif isinstance(item, dict):
@@ -854,7 +1088,6 @@ class DiffBuilder:
 
     def _undo_dataclass_removed(self, item):
         if dataclasses.is_dataclass(item):
-            # print("\n_undo_dataclass_removed:", self._get_dataclass_key(item))
             self._removed_dataclasses.pop(self._get_dataclass_key(item), None)
 
     def _get_dataclass_key(self, item):
@@ -866,7 +1099,9 @@ class DiffBuilder:
 
     def _configure_dataclass(self, item, parent, frozen, configure_setattr_only=False):
         if dataclasses.is_dataclass(item):
-            # print("\n_configure_dataclass:", item, frozen, configure_setattr_only)
+            logger.debug(
+                "\n_configure_dataclass: %s %s %s", item, frozen, configure_setattr_only
+            )
 
             if parent:
                 if parent is item:
@@ -897,12 +1132,14 @@ class DiffBuilder:
                             value if not name.startswith("on_") else value is not None
                         )
                         if old_value != new_value:
-                            # print(
+                            # logger.debug(
                             #     f"\n\nset_attr: {obj.__class__.__name__}.{name} = "
                             #     f"{new_value}, old: {old_value}"
                             # )
                             changes = getattr(obj, "__changes")
                             changes[name] = (old_value, new_value)
+                            if hasattr(obj, "_notify"):
+                                obj._notify(name, new_value)
                 object.__setattr__(obj, name, value)
 
             item.__class__.__setattr__ = control_setattr  # type: ignore
@@ -910,7 +1147,7 @@ class DiffBuilder:
             if self.control_cls and isinstance(item, self.control_cls):
                 if not configure_setattr_only:
                     item.build()
-                    item.before_update()
+                    item._before_update_safe()
                     object.__setattr__(item, "_initialized", True)
                 yield item