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))
 
     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:
     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)
 
         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
 
 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)
 
                 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)
     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))
 
 
         return name + str(0 if not digits else (int(digits) + 1))
 
 

-class _User(NickUserHost):
+class _User(_NickUserHost):

     modes: str = '?'
 
     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.'
     @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())
                 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_
         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
         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}
             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:
         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)
         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'}:
             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]:
                     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
 
                     return True
         return False
 


@@ -671,7 +644,7 @@ class Client(ABC, ClientQueueMixin):
 
     def _on_connect(self) -> None:
         assert self.conn is not None
 
     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=(
         self.db.connection_state = 'connected'
         self.caps.start_negotation()
         self.send(IrcMessage(verb='USER', params=(