Get rid of complications like .from_silent or .set_updating.

diff --git a/ircplom/client.py b/ircplom/client.py
index ee1c775f20bf2fe56c634a9f5a4cdfc4a2367475..a8a6d30a9df54fac3eb96fc579e21e16a625d5a8 100644 (file)
--- a/ircplom/client.py
+++ b/ircplom/client.py
@@ -163,29 +163,11 @@ class _UpdatingMixin(AutoAttrMixin):
     def _make_attr(self, cls: Callable, key: str):
         return cls(on_update=lambda *steps: self._on_update(key, *steps))
 
-    @staticmethod
-    def _silenced_key(key: str, encode=True) -> str:
-        prefix = '__SILENCE__'
-        if encode:
-            return prefix + key
-        return key[len(prefix):] if key.startswith(prefix) else ''
-
     def __setattr__(self, key: str, value) -> None:
-        if (s_key := self._silenced_key(key, encode=False)):
-            super().__setattr__(s_key, value)
-            return
         super().__setattr__(key, value)
         if hasattr(self, '_on_update') and key in self._deep_annotations():
             self._on_update(key)
 
-    @classmethod
-    def from_silent(cls, original, on_update: Callable) -> Self:
-        'From non-updating original return updating variant.'
-        obj = cls(on_update=on_update)
-        for key in cls._deep_annotations().keys():
-            setattr(obj, cls._silenced_key(key), getattr(original, key))
-        return obj
-
 
 class _UpdatingDict(_UpdatingMixin, _Dict[DictItem]):
     _create_if_none: Optional[dict[str, Any]] = None
@@ -204,12 +186,6 @@ class _UpdatingDict(_UpdatingMixin, _Dict[DictItem]):
                 self._dict[key] = self._item_cls(**kw)
         return super().__getitem__(key)
 
-    def set_updating(self, key: str, val) -> None:
-        'Set item at key from non-updating val into updating one.'
-        self[key] = self._item_cls.from_silent(
-            original=val,
-            on_update=lambda *steps: self._on_update(key, *steps))
-
     def __setitem__(self, key: str, val: DictItem) -> None:
         super().__setitem__(key, val)
         self._on_update(key)
@@ -429,14 +405,9 @@ class _NickUserHost(NickUserHost):
         return name + str(0 if not digits else (int(digits) + 1))
 
 
-class _User(NickUserHost):
+class _User(_NickUserHost):
     modes: str = '?'
 
-    @classmethod
-    def from_nickuserhost(cls, nuh: NickUserHost) -> Self:
-        'Create with nuh fields set.'
-        return cls(nuh.nick, nuh.user, nuh.host)
-
     @property
     def id_(self) -> str:
         'To be set to key inside dictionary if placed into one.'
@@ -507,7 +478,7 @@ class _UpdatingUsersDict(_UpdatingDict[_UpdatingUser]):
                 assert stored.user != '?'
         elif create_if_none:
             id_ = str(uuid4())
-            self.set_updating(id_, _User.from_nickuserhost(nickuserhost))
+            self[id_].nickuserhost = nickuserhost
         else:
             return None
         return id_
@@ -525,11 +496,13 @@ class _ClientDb(_UpdatingMixin, SharedClientDbFields):
         attr = super().__getattribute__(key)
         if key == 'isupport' and not attr._defaults:
             attr._defaults = ISUPPORT_DEFAULTS
-        elif key == 'channels' and not attr._create_if_none:
+        elif key == 'channels' and attr._create_if_none is None:
             attr._create_if_none = {
                     'userid_for_nickuserhost': self.users.id_for_nickuserhost,
                     'get_membership_prefixes': self._get_membership_prefixes,
                     'purge_users': self.purge_users}
+        elif key in {'users', 'caps'} and attr._create_if_none is None:
+            attr._create_if_none = {}
         return attr
 
     def clear(self) -> None:
@@ -605,7 +578,7 @@ class _CapsManager:
         for item in items:
             if verb == 'NEW':
                 key, data = _Dict.key_val_from_eq_str(item)
-                self._dict.set_updating(key, ServerCapability(data=data))
+                self._dict[key].data = data
             elif verb == 'DEL':
                 del self._dict[item]
             elif verb in {'ACK', 'NACK'}:
@@ -628,8 +601,8 @@ class _CapsManager:
                     assert set() == list_set & naks
                     for key, data in [_Dict.key_val_from_eq_str(entry)
                                       for entry in self._ls.completed]:
-                        self._dict.set_updating(key, ServerCapability(
-                            data=data, enabled=key in self._list.completed))
+                        self._dict[key].data = data
+                        self._dict[key].enabled = key in self._list.completed
                     return True
         return False
 
@@ -671,7 +644,7 @@ class Client(ABC, ClientQueueMixin):
 
     def _on_connect(self) -> None:
         assert self.conn is not None
-        self.db.users.set_updating('me', _User('?', getuser(), '?'))
+        self.db.users['me'].nickuserhost = NickUserHost(user=getuser())
         self.db.connection_state = 'connected'
         self.caps.start_negotation()
         self.send(IrcMessage(verb='USER', params=(