ferogram 0.5.3__tar.gz → 0.5.3b2__tar.gz

{ferogram-0.5.3 → ferogram-0.5.3b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ferogram
-Version: 0.5.3
+Version: 0.5.3b2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -32,7 +32,7 @@ Project-URL: Tracker, https://github.com/ankit-chaubey/ferogram-py/issues
 ![License](https://img.shields.io/badge/License-MIT%20%7C%20Apache--2.0-64748B?style=flat-square)
 ![Telegram](https://img.shields.io/badge/Telegram-FerogramChat-06B6D4?style=flat-square&logo=telegram&logoColor=white)
 
-**A modern, elegant, asynchronous MTProto framework for building Telegram user clients and bots in Python.**
+**A modern, elegant, asynchronous MTProto framework for building Telegram clients and bots in Python.**
 
 </div>
 

{ferogram-0.5.3 → ferogram-0.5.3b2}/README.md

@@ -8,7 +8,7 @@
 ![License](https://img.shields.io/badge/License-MIT%20%7C%20Apache--2.0-64748B?style=flat-square)
 ![Telegram](https://img.shields.io/badge/Telegram-FerogramChat-06B6D4?style=flat-square&logo=telegram&logoColor=white)
 
-**A modern, elegant, asynchronous MTProto framework for building Telegram user clients and bots in Python.**
+**A modern, elegant, asynchronous MTProto framework for building Telegram clients and bots in Python.**
 
 </div>
 

{ferogram-0.5.3 → ferogram-0.5.3b2}/ferogram/client.py

@@ -631,6 +631,12 @@ class Client(_RichMixin):
         self._transfer_semaphore      = asyncio.Semaphore(self._transfer_limits.max_tcp_connections)
         self._conn: DcConnection | None = None
         self._frame_pump_task: asyncio.Task | None = None
+        # Periodic flush of the peer access-hash cache to the session file.
+        # Mirrors the Rust core's dirty-flag + 60s interval snapshot saver:
+        # the cache changes far more often than it's worth hitting disk for,
+        # so writes are batched instead of happening on every new peer.
+        self._peer_cache_save_task: asyncio.Task | None = None
+        self._peer_cache_save_interval = 60
         self._dc_id: int = 0
         # DCs we've already bound a worker connection's auth key to via
         # auth.importAuthorization this process run (export tokens are
@@ -950,22 +956,30 @@ class Client(_RichMixin):
             for _ in range(self._workers)
         ]
         try:
-            # Seed pts/qts/date/seq. MessageBox.set_state is only valid
-            # while empty, so this only ever runs once per MessageBox
-            # lifetime (i.e. not again after a DC migration - the box
-            # already has state by then).
+            # Seed pts/qts/date/seq. seed_state() re-checks emptiness and
+            # writes atomically in one lock acquisition on the Rust side, so
+            # a real update landing during the getState RPC below (this box
+            # is bound to the live connection) can't race the write and
+            # trip MessageBox's is-empty invariant - it just means seeding
+            # is skipped because the live update already got there first.
             if await self._message_box.is_empty():
                 try:
                     state = await self._rpc({"_": "updates.getState"})
-                    await self._message_box.set_state(
-                        state.get("pts", 0), state.get("qts", 0),
-                        state.get("date", 0), state.get("seq", 0),
-                    )
-                    self._log.debug(
-                        "seeded state: pts=%s qts=%s date=%s seq=%s",
+                    seeded = await self._message_box.seed_state(
                         state.get("pts", 0), state.get("qts", 0),
                         state.get("date", 0), state.get("seq", 0),
                     )
+                    if seeded:
+                        self._log.debug(
+                            "seeded state: pts=%s qts=%s date=%s seq=%s",
+                            state.get("pts", 0), state.get("qts", 0),
+                            state.get("date", 0), state.get("seq", 0),
+                        )
+                    else:
+                        self._log.debug(
+                            "getState returned but message_box was already "
+                            "seeded by a live update in the meantime; skipped"
+                        )
                 except Exception as e:
                     self._log.warning("getState failed: %s", e)
 
@@ -1372,6 +1386,98 @@ class Client(_RichMixin):
         for ch in obj.get("chats") or []:
             self._peer_cache.store_chat_entity(ch)
 
+    async def _load_persisted_update_state(self) -> None:
+        """If `catch_up=True`, restore `MessageBox` from whatever
+        pts/qts/date/seq state was persisted last run, so `getDifference`
+        resumes from the pre-shutdown position instead of jumping straight
+        to the current server state and silently skipping whatever came in
+        while disconnected. No-op when `catch_up` is off, or when nothing
+        has been saved yet (first run, fresh session) - the existing
+        `MessageBox()` in `__init__` is left as-is and gets seeded from a
+        fresh `updates.getState` at the start of `_run_updates()`, same as
+        before."""
+        if not self.catch_up:
+            return
+        conn = self._require_conn()
+        pts, qts, date, seq, channels = await conn.get_persisted_update_state()
+        if pts <= 0:
+            self._log.debug(
+                "catch_up requested but no saved update state; starting fresh"
+            )
+            return
+        self._message_box = MessageBox.load(pts, qts, date, seq, channels)
+        self._log.debug(
+            "update state restored: pts=%d, qts=%d, seq=%d, %d channels tracked",
+            pts, qts, seq, len(channels),
+        )
+
+    async def _flush_update_state(self) -> None:
+        """Push the current pts/qts/date/seq snapshot into the Rust
+        binding's in-memory session record and persist it, so a future
+        `catch_up=True` run has something real to load. Cheap enough to
+        call unconditionally on every autosave tick and on shutdown -
+        unlike the peer cache there's no dirty flag, since pts advances on
+        essentially every update."""
+        conn = self._conn
+        if conn is None:
+            return
+        pts, qts, date, seq, channels = await self._message_box.session_state()
+        if pts <= 0:
+            return
+        await conn.sync_persisted_update_state(pts, qts, date, seq, channels)
+        await conn.save_session()
+
+    async def _load_persisted_peer_cache(self) -> None:
+        """Seed `self._peer_cache` from whatever the session file already
+        has, right after connect() and before the first RPC. Without this,
+        every peer has to be re-resolved from scratch each run even though
+        the Rust binding already persisted them - see
+        `DcConnection.get_persisted_peers()`."""
+        conn = self._require_conn()
+        peers, min_peers = await conn.get_persisted_peers()
+        self._peer_cache.load_persisted(peers, min_peers)
+        cache = self._peer_cache
+        self._log.debug(
+            "peer cache restored: %d users, %d channels, %d communities, "
+            "%d chats, %d channels_min, %d min-peer contexts",
+            len(cache._users),
+            len(cache._channels),
+            len(cache._communities),
+            len(cache._chats),
+            len(cache.channels_min),
+            len(cache.min_contexts),
+        )
+
+    async def _flush_peer_cache(self) -> None:
+        """Push the current peer cache into the Rust binding's in-memory
+        snapshot and persist it. Safe to call even when nothing changed -
+        callers should check `self._peer_cache.dirty` first to avoid
+        needless disk writes on the autosave interval."""
+        conn = self._conn
+        if conn is None:
+            return
+        peers, min_peers = self._peer_cache.to_persisted()
+        await conn.sync_persisted_peers(peers, min_peers)
+        await conn.save_session()
+        self._peer_cache.dirty = False
+
+    async def _peer_cache_autosave_loop(self) -> None:
+        try:
+            while True:
+                await asyncio.sleep(self._peer_cache_save_interval)
+                if self._peer_cache.dirty:
+                    try:
+                        await self._flush_peer_cache()
+                    except Exception as exc:
+                        self._log.warning("peer cache autosave failed: %s", exc)
+                try:
+                    await self._flush_update_state()
+                except Exception as exc:
+                    self._log.warning("update state autosave failed: %s", exc)
+        except asyncio.CancelledError:
+            pass
+
+
 
     async def start(
         self,
@@ -1422,7 +1528,10 @@ class Client(_RichMixin):
         self._dc_id = self._conn.dc_id
         self._log.extra["client"] = f"{_session_tag(self.session, self.session_string)} dc{self._dc_id}"
         self._log.info("connected to DC%d in %dms", self._dc_id, connect_ms)
+        await self._load_persisted_update_state()
         self._conn.bind_message_box(self._message_box)
+        await self._load_persisted_peer_cache()
+        self._peer_cache_save_task = asyncio.create_task(self._peer_cache_autosave_loop())
         if self._future_auth_token is not None:
             # Don't clobber a real token the session already persisted
             # from a previous sign_out() with a stale constructor value.
@@ -1485,10 +1594,26 @@ class Client(_RichMixin):
         print("\nPlease ensure your usage complies with Telegram's API Terms of Service.")
 
     async def stop(self) -> None:
+        """Disconnect and persist final state. Does NOT log the account out
+        of Telegram - the auth key and session stay valid for next start().
+        Call `sign_out()` yourself first if you actually want to deauthorize."""
         if self._conn:
-            await self.sign_out()
+            if self._peer_cache_save_task is not None:
+                self._peer_cache_save_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await self._peer_cache_save_task
+                self._peer_cache_save_task = None
+            with suppress(Exception):
+                # Final unconditional flush so nothing learned since the
+                # last autosave tick is lost - mirrors the Rust core's
+                # save-on-shutdown in its own snapshot saver task.
+                await self._flush_peer_cache()
+            with suppress(Exception):
+                await self._flush_update_state()
+            with suppress(Exception):
+                await self._conn.save_session()
             self._conn = None
-            self._log.info("signed out")
+            self._log.info("disconnected")
 
     async def run_until_disconnected(self) -> None:
         await self.start()
@@ -1502,6 +1627,15 @@ class Client(_RichMixin):
                 self._frame_pump_task.cancel()
                 with suppress(asyncio.CancelledError):
                     await self._frame_pump_task
+            if self._peer_cache_save_task is not None:
+                self._peer_cache_save_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await self._peer_cache_save_task
+                self._peer_cache_save_task = None
+            with suppress(Exception):
+                await self._flush_peer_cache()
+            with suppress(Exception):
+                await self._flush_update_state()
 
     def run(self) -> None:
         try:
@@ -1513,8 +1647,7 @@ class Client(_RichMixin):
         return await self.start()
 
     async def __aexit__(self, *_: Any) -> None:
-        if self._conn:
-            self._conn = None
+        await self.stop()
 
 
     async def is_authorized(self) -> bool:

{ferogram-0.5.3 → ferogram-0.5.3b2}/ferogram/raw/proxy.py

@@ -176,28 +176,57 @@ class PeerCache:
         self._channels:   dict[int, int] = {}    # channel_id   → access_hash
         self._communities: dict[int, int] = {}   # community_id → access_hash
         self._chats:      set[int]       = set() # basic group ids (no hash)
+        # Channels seen with min=true: real channels, no usable access_hash
+        # yet. Never put these in _chats - that would make them resolve as
+        # a basic InputPeerChat, which is a fatal RPC failure. Mirrors
+        # ferogram-rust's `channels_min`.
+        self.channels_min: set[int] = set()
+        # user_id -> (peer_id, msg_id) for min users seen in a message
+        # context, addressable only via InputPeerUserFromMessage. Python
+        # doesn't populate this itself yet (that needs per-message context
+        # threading through _populate_cache, which nothing calls with today),
+        # but it round-trips whatever a Rust-core session already saved here
+        # instead of silently dropping it on the next save.
+        self.min_contexts: dict[int, tuple[int, int]] = {}
+        # Set whenever a store_* call actually changes something, so the
+        # client knows a disk flush is worth doing instead of writing an
+        # unchanged snapshot every autosave tick.
+        self.dirty = False
 
     def store_user(self, user_id: int, access_hash: int) -> None:
         self._store_hash(self._users, user_id, access_hash)
 
     def store_channel(self, channel_id: int, access_hash: int) -> None:
         self._store_hash(self._channels, channel_id, access_hash)
+        self.channels_min.discard(channel_id)
 
     def store_community(self, community_id: int, access_hash: int) -> None:
         self._store_hash(self._communities, community_id, access_hash)
 
-    @staticmethod
-    def _store_hash(bucket: dict[int, int], key: int, access_hash: int) -> None:
+    def store_channel_min(self, channel_id: int) -> None:
+        """Track a channel seen with min=true. No access_hash yet - just
+        existence, so `_resolve_int_peer` doesn't have to guess whether an
+        uncached id is a channel worth fetching or something else."""
+        if channel_id not in self._channels and channel_id not in self.channels_min:
+            self.channels_min.add(channel_id)
+            self.dirty = True
+
+    def _store_hash(self, bucket: dict[int, int], key: int, access_hash: int) -> None:
         # Never overwrite a valid non-zero hash with zero - a zero hash from
         # a later, less-detailed response shouldn't clobber one we already
         # resolved. Same rule as ferogram-rust's cache_user/cache_chat.
         if access_hash != 0:
-            bucket[key] = access_hash
-        else:
-            bucket.setdefault(key, 0)
+            if bucket.get(key) != access_hash:
+                bucket[key] = access_hash
+                self.dirty = True
+        elif key not in bucket:
+            bucket[key] = 0
+            self.dirty = True
 
     def store_chat(self, chat_id: int) -> None:
-        self._chats.add(chat_id)
+        if chat_id not in self._chats:
+            self._chats.add(chat_id)
+            self.dirty = True
 
     def store_chat_entity(self, chat: dict) -> None:
         """Route a raw `Chat` dict into the right bucket by its `_` type.
@@ -205,15 +234,20 @@ class PeerCache:
         Covers `channel`/`channelForbidden`, `community`/`communityForbidden`
         (both keyed by id + access_hash, addressed like a channel on the
         wire), and basic `chat`/`chatForbidden` (existence only, no hash).
-        `min` entities are skipped - same as the rest of the cache, there is
-        no separate min-tracking bucket here.
+        A min channel is tracked in `channels_min` (existence only, mirrors
+        ferogram-rust); a min community or anything else with `min` is
+        skipped, same as before.
         """
-        if not isinstance(chat, dict) or chat.get("min"):
+        if not isinstance(chat, dict):
             return
         t = chat.get("_", "")
         cid = chat.get("id")
         if cid is None:
             return
+        if chat.get("min"):
+            if t in _CHANNEL_TYPES:
+                self.store_channel_min(cid)
+            return
         if t in _COMMUNITY_TYPES:
             ah = chat.get("access_hash")
             if ah is not None:
@@ -227,6 +261,45 @@ class PeerCache:
         # anything else (e.g. chatEmpty) is a no-op - mirrors the catch-all
         # arm in ferogram-rust's PeerCache::cache_chat
 
+    def to_persisted(self) -> tuple[list[tuple], list[tuple]]:
+        """Flatten this cache into the tuple shapes `DcConnection.
+        sync_persisted_peers()` expects: `(peers, min_peers)`. `channel_kind`
+        is always `None` here - Python doesn't track it yet, so a channel
+        saved by ferogram-py round-trips without one even if the Rust core
+        had recorded it previously."""
+        peers: list[tuple] = []
+        for uid, ah in self._users.items():
+            peers.append((uid, ah, False, False, None, False))
+        for cid, ah in self._channels.items():
+            peers.append((cid, ah, True, False, None, False))
+        for cid in self.channels_min:
+            peers.append((cid, 0, True, False, None, False))
+        for cid in self._chats:
+            peers.append((cid, 0, False, True, None, False))
+        for cid, ah in self._communities.items():
+            peers.append((cid, ah, False, False, None, True))
+        min_peers = [(uid, peer_id, msg_id) for uid, (peer_id, msg_id) in self.min_contexts.items()]
+        return peers, min_peers
+
+    def load_persisted(self, peers: list[tuple], min_peers: list[tuple]) -> None:
+        """Seed this cache from `DcConnection.get_persisted_peers()` output,
+        called once right after connect() so peers resolved in a previous
+        run don't need re-resolving. Does not touch `dirty`."""
+        for id_, access_hash, is_channel, is_chat, _kind, is_community in peers:
+            if is_chat:
+                self._chats.add(id_)
+            elif is_community:
+                self._communities[id_] = access_hash
+            elif is_channel:
+                if access_hash:
+                    self._channels[id_] = access_hash
+                else:
+                    self.channels_min.add(id_)
+            else:
+                self._users[id_] = access_hash
+        for uid, peer_id, msg_id in min_peers:
+            self.min_contexts[uid] = (peer_id, msg_id)
+
     def get_user(self, user_id: int) -> int | None:
         return self._users.get(user_id)
 

{ferogram-0.5.3 → ferogram-0.5.3b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name        = "ferogram"
-version     = "0.5.3"
+version     = "0.5.3b2"
 description = "A modern, elegant, asynchronous MTProto framework for building Telegram clients and bots in Python."
 readme      = "README.md"
 license     = { text = "MIT OR Apache-2.0" }

{ferogram-0.5.3 → ferogram-0.5.3b2}/src/connection.rs

@@ -16,7 +16,10 @@ use ferogram_msgbox::MessageBoxes;
 use ferogram_mtsender::{
     AutoSleep, DcConnection as RustConn, FrameEvent, RetryLoop, RpcEnqueue, spawn_sender_task,
 };
-use ferogram_session::{DcEntry, PersistedSession, SessionBackend, default_dc_addresses};
+use ferogram_session::{
+    CachedMinPeer, CachedPeer, ChannelKind, DcEntry, PersistedSession, SessionBackend,
+    UpdatesStateSnap, default_dc_addresses,
+};
 use ferogram_tl_types::Deserializable;
 use pyo3::prelude::*;
 use pyo3_async_runtimes::tokio::future_into_py;
@@ -735,6 +738,139 @@ impl DcConnection {
         })
     }
 
+    /// Persisted update-sequence state (pts/qts/date/seq/channels), if any.
+    ///
+    /// Same tuple shape as `MessageBox.session_state()` / `MessageBox.load()`,
+    /// so callers round-trip directly:
+    ///
+    ///     pts, qts, date, seq, channels = await conn.get_persisted_update_state()
+    ///     msg_box = MessageBox.load(pts, qts, date, seq, channels) if pts > 0 else MessageBox()
+    ///
+    /// `pts == 0` means no update state has ever been saved for this session.
+    #[allow(clippy::type_complexity)]
+    fn get_persisted_update_state<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        let persisted = Arc::clone(&self.persisted);
+        future_into_py(py, async move {
+            let p = persisted.lock().await;
+            let us = &p.updates_state;
+            let channels: Vec<(i64, i32)> = us.channels.clone();
+            Ok((us.pts, us.qts, us.date, us.seq, channels))
+        })
+    }
+
+    /// Store an update-sequence snapshot (from `MessageBox.session_state()`)
+    /// into the in-memory session record. Updates memory only - pair with
+    /// `save_session()` to persist to disk, same pattern as
+    /// `sync_persisted_peers()`.
+    fn sync_persisted_update_state<'py>(
+        &self,
+        py: Python<'py>,
+        pts: i32,
+        qts: i32,
+        date: i32,
+        seq: i32,
+        channels: Vec<(i64, i32)>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let persisted = Arc::clone(&self.persisted);
+        future_into_py(py, async move {
+            let mut p = persisted.lock().await;
+            p.updates_state = UpdatesStateSnap {
+                pts,
+                qts,
+                date,
+                seq,
+                channels,
+            };
+            Ok(())
+        })
+    }
+
+    /// Peer access-hash cache loaded from the session file, if any.
+    ///
+    /// Returns `(peers, min_peers)`:
+    /// - `peers`: `(id, access_hash, is_channel, is_chat, channel_kind, is_community)`
+    ///   tuples. `channel_kind` is `0`=broadcast, `1`=megagroup, `2`=gigagroup,
+    ///   or `None` for users, chats, communities, and channels saved before
+    ///   kind tracking existed.
+    /// - `min_peers`: `(user_id, peer_id, msg_id)` tuples - users seen with
+    ///   `min=true`, addressable only via `InputPeerUserFromMessage` using
+    ///   the peer and message where they appeared.
+    ///
+    /// Call this once after `connect()` to seed the Python-side peer cache
+    /// so previously-resolved peers survive a restart instead of needing
+    /// re-resolution on first use.
+    #[allow(clippy::type_complexity)]
+    fn get_persisted_peers<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        let persisted = Arc::clone(&self.persisted);
+        future_into_py(py, async move {
+            let p = persisted.lock().await;
+            let peers: Vec<(i64, i64, bool, bool, Option<u8>, bool)> = p
+                .peers
+                .iter()
+                .map(|c| {
+                    (
+                        c.id,
+                        c.access_hash,
+                        c.is_channel,
+                        c.is_chat,
+                        c.channel_kind.map(ChannelKind::to_byte),
+                        c.is_community,
+                    )
+                })
+                .collect();
+            let min_peers: Vec<(i64, i64, i32)> = p
+                .min_peers
+                .iter()
+                .map(|m| (m.user_id, m.peer_id, m.msg_id))
+                .collect();
+            Ok((peers, min_peers))
+        })
+    }
+
+    /// Replace the in-memory peer cache snapshot from Python's `PeerCache`.
+    ///
+    /// Same tuple shapes as [`Self::get_persisted_peers`]. Updates memory
+    /// only - does not touch disk. Pair with periodic or shutdown-time
+    /// `save_session()` calls, mirroring the Rust core's dirty-flag +
+    /// interval flush (see `Client`'s full-session snapshot saver): the
+    /// peer cache changes far more often than it's worth writing to disk,
+    /// so batching the writes avoids hammering the session backend on
+    /// every single new peer.
+    #[allow(clippy::type_complexity)]
+    fn sync_persisted_peers<'py>(
+        &self,
+        py: Python<'py>,
+        peers: Vec<(i64, i64, bool, bool, Option<u8>, bool)>,
+        min_peers: Vec<(i64, i64, i32)>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let persisted = Arc::clone(&self.persisted);
+        future_into_py(py, async move {
+            let mut p = persisted.lock().await;
+            p.peers = peers
+                .into_iter()
+                .map(
+                    |(id, access_hash, is_channel, is_chat, kind_byte, is_community)| CachedPeer {
+                        id,
+                        access_hash,
+                        is_channel,
+                        is_chat,
+                        channel_kind: kind_byte.and_then(ChannelKind::from_byte),
+                        is_community,
+                    },
+                )
+                .collect();
+            p.min_peers = min_peers
+                .into_iter()
+                .map(|(user_id, peer_id, msg_id)| CachedMinPeer {
+                    user_id,
+                    peer_id,
+                    msg_id,
+                })
+                .collect();
+            Ok(())
+        })
+    }
+
     /// Streaming mode only (`connect(stream_updates=True)`): await the next
     /// event from the sender task's background read loop.
     ///

{ferogram-0.5.3 → ferogram-0.5.3b2}/src/message_box.rs

@@ -118,6 +118,49 @@ impl PyMessageBox {
         })
     }
 
+    /// Atomic `is_empty() -> set_state()`, in a single lock acquisition.
+    ///
+    /// The caller has to `await` an `updates.getState` RPC (tens to
+    /// hundreds of ms) between deciding to seed and having a state to seed
+    /// with. If this box is bound to a live connection (`bind_message_box`),
+    /// a real pushed update can land and populate it during that RPC. Doing
+    /// the plain `is_empty()` check before the RPC and `set_state()` after
+    /// leaves a window where that race turns into `set_state`'s
+    /// `debug_assert!(self.is_empty())` panicking on a box something else
+    /// just populated.
+    ///
+    /// This re-checks emptiness at the moment of the write, atomically, and
+    /// simply skips the write if something else got there first - exactly
+    /// what the Rust core's `sync_pts_state()` does by holding its
+    /// `tokio::Mutex` guard across both the check and the write. Returns
+    /// `true` if it actually seeded the state, `false` if it was skipped
+    /// because the box was no longer empty.
+    fn seed_state<'py>(
+        &self,
+        py: Python<'py>,
+        pts: i32,
+        qts: i32,
+        date: i32,
+        seq: i32,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let inner = Arc::clone(&self.inner);
+        future_into_py(py, async move {
+            let mut mb = inner.lock().await;
+            if mb.is_empty() {
+                mb.set_state(tl::types::updates::State {
+                    pts,
+                    qts,
+                    date,
+                    seq,
+                    unread_count: 0,
+                });
+                Ok(true)
+            } else {
+                Ok(false)
+            }
+        })
+    }
+
     /// Record a channel's pts from `GetDialogs` - a no-op if already tracked.
     fn try_set_channel_state<'py>(
         &self,