spluspy 2.1.6__tar.gz → 2.1.7__tar.gz

{spluspy-2.1.6 → spluspy-2.1.7}/CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to SplusPy will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [2.1.7] - 2026-07-15
+
+### Fixed
+- Fixed critical reconnection bug: `_reconnect()` now resets `_user_connected` flag so send/recv loops restart after connection drop
+- Fixed `_connection_monitor` checking wrong attribute name (`_update_task` → `_updates_handle`)
+- Added keepalive loop monitoring to `_connection_monitor`
+- Added clean-exit detection for update loop in connection monitor
+- Wrapped connection monitor body in try/except to prevent silent monitor death
+
 ## [2.1.3] - 2026-07-13
 
 ### Fixed

{spluspy-2.1.6 → spluspy-2.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.1.6
+Version: 2.1.7
 Summary: A modern async Python library for interacting with Soroush Plus
 Project-URL: Homepage, https://github.com/Itskillmaster/spluspy
 Project-URL: Documentation, https://github.com/Itskillmaster/spluspy#readme

{spluspy-2.1.6 → spluspy-2.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "spluspy"
-version = "2.1.6"
+version = "2.1.7"
 description = "A modern async Python library for interacting with Soroush Plus"
 readme = "README.md"
 license = "MIT"

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/__version__.py

@@ -1,6 +1,6 @@
 """SplusPy version information."""
 
-__version__ = "2.1.6"
+__version__ = "2.1.7"
 __author__ = "Ali Mirshekari"
 __license__ = "MIT"
 __url__ = "https://github.com/Itskillmaster/spluspy"

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/account.py

@@ -242,5 +242,6 @@ class AccountMethods:
             async with _TakeoutClient(True, self, None) as takeout:
                 takeout.success = success
         except ValueError as e:
+            _log.debug('Failed to end takeout: %s', e)
             return False
         return True

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/auth.py

@@ -160,7 +160,7 @@ class AuthMethods:
                             'you are accidentally reusing an existing session'
                         )
             except Exception as e:
-                pass
+                _log.debug('Failed to verify existing session user: %s', e)
 
             return self
 
@@ -352,6 +352,7 @@ class AuthMethods:
             except Exception as e:
                 # get_me may fail on Soroush (GetUsersRequest returns 500).
                 # Check authorization via GetState instead.
+                _log.debug('get_me failed, checking auth state: %s', e)
                 if await self.is_user_authorized():
                     return None
             if me:
@@ -399,6 +400,7 @@ class AuthMethods:
                 try:
                     me = await self.get_me()
                 except Exception as e:
+                    _log.debug('get_me failed after auth check: %s', e)
                     me = None
                 if me:
                     return await self._on_login(me)
@@ -419,7 +421,7 @@ class AuthMethods:
                                      int(state.date.timestamp()), state.seq, 0),
                         [])
                 except Exception as e:
-                    pass
+                    _log.debug('Failed to initialize message box during login: %s', e)
                 return None
             raise
 
@@ -535,6 +537,9 @@ class AuthMethods:
                 if _retry_count > 2:
                     raise
                 self._phone_code_hash.pop(phone, None)
+                self._log[__name__].debug(
+                    "Phone code expired in ResendCodeRequest, requesting a new code"
+                )
                 return await self.send_code_request(
                     phone, force_sms=False, _retry_count=_retry_count+1)
 
@@ -603,6 +608,7 @@ class AuthMethods:
         try:
             await self(functions.auth.LogOutRequest())
         except errors.RPCError as e:
+            _log.debug('Logout failed: %s', e)
             return False
 
         self._mb_entity_cache.set_self_user(None, None, None)

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/chats.py

@@ -88,7 +88,7 @@ class _ChatAction:
                 await self._client(self._request)
                 await asyncio.sleep(self._delay)
         except ConnectionError as e:
-            pass
+            _log.debug('Connection error during typing action: %s', e)
         except asyncio.CancelledError:
             if self._auto_cancel:
                 await self._client(functions.messages.SetTypingRequest(

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/dialogs.py

@@ -467,6 +467,7 @@ class DialogMethods:
                 ))
             except errors.PeerIdInvalidError as e:
                 # Happens if we didn't have the deactivated information
+                _log.debug('PeerIdInvalidError when deleting chat: %s', e)
                 result = None
         else:
             result = None
@@ -563,6 +564,7 @@ class DialogMethods:
                 await self.delete_dialog(entity, revoke=revoke)
                 result["success"] += 1
                 result["details"].append({"id": user_id, "title": title, "status": "deleted"})
+                _log.debug("delete_all_private: deleted %s (%d)", title, user_id)
             except Exception as exc:
                 result["failed"] += 1
                 result["details"].append({"id": user_id, "title": title, "status": "failed"})

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/downloads.py

@@ -108,10 +108,12 @@ class _DirectDownloadIter(RequestIter):
                 raise
 
             self._timed_out = True
+            self.client._log[__name__].debug('Got timeout while downloading file, retrying once')
             await asyncio.sleep(TIMED_OUT_SLEEP)
             return await self._request()
 
         except errors.FileMigrateError as e:
+            self.client._log[__name__].debug('File lives in another DC')
             self._sender = await self.client._borrow_exported_sender(e.new_dc)
             self._exported = True
             return await self._request()
@@ -123,6 +125,7 @@ class _DirectDownloadIter(RequestIter):
                     or self.request.location.thumb_size != '':
                 raise
 
+            self.client._log[__name__].debug('File ref expired during download; refetching message')
             chat, msg_id = self._msg_data
             msg = await self.client.get_messages(chat, ids=msg_id)
 
@@ -583,6 +586,7 @@ class DownloadMethods:
             if in_memory:
                 return f.getvalue()
         except _CdnRedirect as e:
+          self._log[__name__].debug('FileCdnRedirect to CDN data center %s', e.cdn_redirect.dc_id)
           return await self._download_file(
               input_location=input_location,
               file=file,
@@ -750,8 +754,12 @@ class DownloadMethods:
                 and stride % MIN_CHUNK_SIZE == 0 \
                 and (limit is None or offset % limit == 0):
             cls = _DirectDownloadIter
+            self._log[__name__].debug('Starting direct file download in chunks of '
+                                     '%d at %d, stride %d', request_size, offset, stride)
         else:
             cls = _GenericDownloadIter
+            self._log[__name__].debug('Starting indirect file download in chunks of '
+                                     '%d at %d, stride %d', request_size, offset, stride)
 
         return cls(
             self,
@@ -1056,6 +1064,7 @@ class DownloadMethods:
                     if x and not isreserved(x)
                 )
             except StopIteration:
+                _log.debug('No valid filename found in possible_names')
                 name = None
 
             if not name:

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/messages.py

@@ -311,6 +311,7 @@ class _IDsIter(RequestIter):
                     functions.channels.GetMessagesRequest(self._entity, ids))
             except errors.MessageIdsEmptyError as e:
                 # All IDs were invalid, use a dummy result
+                _log.debug('MessageIdsEmptyError for channel messages: %s', e)
                 r = types.messages.MessagesNotModified(len(ids))
         else:
             r = await self.client(functions.messages.GetMessagesRequest(ids))

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/telegrambaseclient.py

@@ -394,7 +394,6 @@ class SoroushPlusBaseClient(abc.ABC):
         # Used for non-sequential updates, in order to terminate all pending tasks on disconnect.
         self._sequential_updates = sequential_updates
         self._event_handler_tasks = set()
-        self._max_handler_tasks = 50  # Limit concurrent handler tasks
 
         self._authorized = None  # None = unknown, False = no, True = yes
 
@@ -575,7 +574,7 @@ class SoroushPlusBaseClient(abc.ABC):
             self_user = await utils.maybe_async(self.session.get_input_entity(self_id))
             self._mb_entity_cache.set_self_user(self_id, None, self_user.access_hash)
         except ValueError as e:
-            pass
+            _base_log.debug('Could not load self user from session: %s', e)
 
         if self._catch_up:
             ss = SessionState(0, 0, False, 0, 0, 0, 0, None)
@@ -611,7 +610,7 @@ class SoroushPlusBaseClient(abc.ABC):
             # Soroush server sends config types with custom constructor IDs
             # and different field layouts than standard SoroushPlus. The response
             # is not used anyway, so we can safely ignore parse errors.
-            pass
+            _base_log.debug('Ignored config parse error during init: %s', e)
 
         # Don't call get_me() here — on Soroush the auth key is not
         # registered until after login, and GetUsersRequest (used by
@@ -672,7 +671,7 @@ class SoroushPlusBaseClient(abc.ABC):
                 #   "Event loop stopped before Future completed."
                 #
                 # However, it doesn't really make a lot of sense.
-                pass
+                _base_log.debug('RuntimeError during disconnect: %s', e)
 
     def set_proxy(self: 'SoroushClient', proxy: typing.Union[tuple, dict]):
         """
@@ -775,6 +774,7 @@ class SoroushPlusBaseClient(abc.ABC):
         """
         Permanently switches the current connection to the new data center.
         """
+        self._log[__name__].debug('Reconnecting to new data center %s', new_dc)
         dc = await self._get_dc(new_dc)
 
         await utils.maybe_async(self.session.set_dc(dc.id, dc.ip_address, dc.port))
@@ -884,6 +884,7 @@ class SoroushPlusBaseClient(abc.ABC):
             proxy=self._proxy,
             local_addr=self._local_addr
         ))
+        self._log[__name__].debug('Exporting auth for new borrowed sender in %s', dc)
         auth = await self(functions.auth.ExportAuthorizationRequest(dc_id))
         self._init_request.query = functions.auth.ImportAuthorizationRequest(id=auth.id, bytes=auth.bytes)
         req = functions.InvokeWithLayerRequest(LAYER, self._init_request)
@@ -899,6 +900,7 @@ class SoroushPlusBaseClient(abc.ABC):
         Once its job is over it should be `_return_exported_sender`.
         """
         async with self._borrow_sender_lock:
+            self._log[__name__].debug('Borrowing sender for dc_id %d', dc_id)
             state, sender = self._borrowed_senders.get(dc_id, (None, None))
 
             if state is None:
@@ -927,6 +929,7 @@ class SoroushPlusBaseClient(abc.ABC):
         been returned, the sender is cleanly disconnected.
         """
         async with self._borrow_sender_lock:
+            self._log[__name__].debug('Returning borrowed sender for dc_id %d', sender.dc_id)
             state, _ = self._borrowed_senders[sender.dc_id]
             state.add_return()
 
@@ -937,6 +940,8 @@ class SoroushPlusBaseClient(abc.ABC):
         async with self._borrow_sender_lock:
             for dc_id, (state, sender) in self._borrowed_senders.items():
                 if state.should_disconnect():
+                    self._log[__name__].debug(
+                        'Disconnecting borrowed sender for DC %d', dc_id)
 
                     # Disconnect should never raise
                     await sender.disconnect()
@@ -951,6 +956,7 @@ class SoroushPlusBaseClient(abc.ABC):
             await utils.maybe_async(session.set_dc(dc.id, dc.ip_address, dc.port))
             self._exported_sessions[cdn_redirect.dc_id] = session
 
+        self._log[__name__].debug('Creating new CDN client')
         client = self.__class__(
             session, self.api_id, self.api_hash,
             proxy=self._proxy,

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/updates.py

@@ -4,6 +4,7 @@ import itertools
 import random
 import sys
 import time
+import traceback
 import typing
 import logging
 import warnings
@@ -283,11 +284,14 @@ class UpdateMethods:
                     if self._sequential_updates:
                         await self._dispatch_update(updates_to_dispatch.popleft())
                     else:
-                        # Respect concurrency limit to prevent memory issues with many groups
-                        if len(self._event_handler_tasks) < self._max_handler_tasks:
-                            task = self.loop.create_task(self._dispatch_update(updates_to_dispatch.popleft()))
-                            self._event_handler_tasks.add(task)
-                            task.add_done_callback(self._event_handler_tasks.discard)
+                        # Spawn one task per loop iteration instead of draining the entire
+                        # deque in a tight while-loop. Draining all at once creates O(n) tasks
+                        # before the event loop gets a chance to run any of them, causing task
+                        # count (and scheduling overhead) to grow unboundedly under high load.
+                        # TODO if _dispatch_update fails for whatever reason, it's not logged! this should be fixed
+                        task = self.loop.create_task(self._dispatch_update(updates_to_dispatch.popleft()))
+                        self._event_handler_tasks.add(task)
+                        task.add_done_callback(self._event_handler_tasks.discard)
 
                     continue
 
@@ -295,6 +299,7 @@ class UpdateMethods:
 
                 get_diff = self._message_box.get_difference()
                 if get_diff:
+                    self._log[__name__].debug('Getting difference for account updates')
                     try:
                         diff = await self(get_diff)
                     except (
@@ -304,10 +309,12 @@ class UpdateMethods:
                         ValueError
                     ) as e:
                         # SoroushPlus is having issues
+                        self._log[__name__].debug('Cannot get difference since SoroushPlus is having issues: %s', type(e).__name__)
                         self._message_box.end_difference()
                         continue
                     except (errors.UnauthorizedError, errors.AuthKeyError) as e:
                         # Not logged in or broken authorization key, can't get difference
+                        self._log[__name__].debug('Cannot get difference since the account is not logged in: %s', type(e).__name__)
                         self._message_box.end_difference()
                         if was_once_logged_in:
                             self._updates_error = e
@@ -334,16 +341,21 @@ class UpdateMethods:
                         # Network is likely down, but it's unclear for how long.
                         # If disconnect is called this task will be cancelled along with the sleep.
                         # If disconnect is not called, getting difference should be retried after a few seconds.
+                        self._log[__name__].debug('Cannot get difference since the network is down: %s: %s', type(e).__name__, e)
                         self._message_box.end_difference()
                         await asyncio.sleep(5)
                         continue
                     updates, users, chats = self._message_box.apply_difference(diff, self._mb_entity_cache)
+                    if updates:
+                        self._log[__name__].debug('Got difference for account updates')
+
                     _preprocess_updates = await self._preprocess_updates(updates, users, chats)
                     updates_to_dispatch.extend(_preprocess_updates)
                     continue
 
                 get_diff = self._message_box.get_channel_difference(self._mb_entity_cache)
                 if get_diff:
+                    self._log[__name__].debug('Getting difference for channel %s updates', get_diff.channel.channel_id)
                     try:
                         diff = await self(get_diff)
                     except (errors.UnauthorizedError, errors.AuthKeyError) as e:
@@ -414,6 +426,10 @@ class UpdateMethods:
                         # Timeout triggered a get difference, but we have been banned in the channel since then.
                         # Because we can no longer fetch updates from this channel, we should stop keeping track
                         # of it entirely.
+                        self._log[__name__].debug(
+                            'Account is now banned in %d so we can no longer fetch updates from it',
+                            get_diff.channel.channel_id
+                        )
                         self._message_box.end_channel_difference(
                             get_diff,
                             PrematureEndReason.BANNED,
@@ -434,6 +450,10 @@ class UpdateMethods:
                         )
                         continue
                     except OSError as e:
+                        self._log[__name__].debug(
+                            'Cannot get difference for channel %d since the network is down: %s: %s',
+                            get_diff.channel.channel_id, type(e).__name__, e
+                        )
                         self._message_box.end_channel_difference(
                             get_diff,
                             PrematureEndReason.TEMPORARY_SERVER_ISSUES,
@@ -443,6 +463,9 @@ class UpdateMethods:
                         continue
 
                     updates, users, chats = self._message_box.apply_channel_difference(get_diff, diff, self._mb_entity_cache)
+                    if updates:
+                        self._log[__name__].debug('Got difference for channel %d updates', get_diff.channel.channel_id)
+
                     _preprocess_updates = await self._preprocess_updates(updates, users, chats)
                     updates_to_dispatch.extend(_preprocess_updates)
                     continue
@@ -475,6 +498,7 @@ class UpdateMethods:
                     try:
                         updates = await asyncio.wait_for(self._updates_queue.get(), deadline_delay)
                     except asyncio.TimeoutError:
+                        self._log[__name__].debug('Timeout waiting for updates expired')
                         continue
                 else:
                     continue
@@ -625,7 +649,6 @@ class UpdateMethods:
                     if conv._custom:
                         await conv._check_custom(built)
 
-        tasks = []
         for builder, callback in self._event_builders:
             event = built[type(builder)]
             if not event:
@@ -640,27 +663,32 @@ class UpdateMethods:
             if not filter:
                 continue
 
-            async def _run_cb(cb=callback, ev=event):
-                try:
-                    await cb(ev)
-                except errors.AlreadyInConversationError:
-                    pass
-                except events.StopPropagation:
-                    pass
-                except Exception as e:
-                    if not isinstance(e, asyncio.CancelledError) or self.is_connected():
-                        self._log[__name__].exception('Unhandled exception on handler')
-
-            tasks.append(_run_cb())
-
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
+            try:
+                await callback(event)
+            except errors.AlreadyInConversationError:
+                name = getattr(callback, '__name__', repr(callback))
+                self._log[__name__].debug(
+                    'Event handler "%s" already has an open conversation, '
+                    'ignoring new one', name)
+            except events.StopPropagation:
+                name = getattr(callback, '__name__', repr(callback))
+                self._log[__name__].debug(
+                    'Event handler "%s" stopped chain of propagation '
+                    'for event %s.', name, type(event).__name__
+                )
+                break
+            except Exception as e:
+                if not isinstance(e, asyncio.CancelledError) or self.is_connected():
+                    name = getattr(callback, '__name__', repr(callback))
+                    self._log[__name__].exception('Unhandled exception on %s', name)
 
     async def _dispatch_event(self: 'SoroushClient', event):
         """
         Dispatches a single, out-of-order event. Used by `AlbumHack`.
         """
-        tasks = []
+        # We're duplicating a most logic from `_dispatch_update`, but all in
+        # the name of speed; we don't want to make it worse for all updates
+        # just because albums may need it.
         for builder, callback in self._event_builders:
             if isinstance(builder, events.Raw):
                 continue
@@ -676,21 +704,24 @@ class UpdateMethods:
             if not filter:
                 continue
 
-            async def _run_cb(cb=callback, ev=event):
-                try:
-                    await cb(ev)
-                except errors.AlreadyInConversationError:
-                    pass
-                except events.StopPropagation:
-                    pass
-                except Exception as e:
-                    if not isinstance(e, asyncio.CancelledError) or self.is_connected():
-                        self._log[__name__].exception('Unhandled exception on handler')
-
-            tasks.append(_run_cb())
-
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
+            try:
+                await callback(event)
+            except errors.AlreadyInConversationError:
+                name = getattr(callback, '__name__', repr(callback))
+                self._log[__name__].debug(
+                    'Event handler "%s" already has an open conversation, '
+                    'ignoring new one', name)
+            except events.StopPropagation:
+                name = getattr(callback, '__name__', repr(callback))
+                self._log[__name__].debug(
+                    'Event handler "%s" stopped chain of propagation '
+                    'for event %s.', name, type(event).__name__
+                )
+                break
+            except Exception as e:
+                if not isinstance(e, asyncio.CancelledError) or self.is_connected():
+                    name = getattr(callback, '__name__', repr(callback))
+                    self._log[__name__].exception('Unhandled exception on %s', name)
 
     async def _handle_auto_reconnect(self: 'SoroushClient'):
         # Use lightweight get_me to let SoroushPlus know we want updates
@@ -701,12 +732,15 @@ class UpdateMethods:
                                         'after reconnect: %s: %s', type(e), e)
 
         try:
+            self._log[__name__].debug(
+                'Asking for the current state after reconnect...')
 
             # If a disconnection occurs, the old known state will be
             # the latest one we were aware of, so we can catch up since
             # the most recent state we were aware of.
             await self.catch_up()
 
+            self._log[__name__].debug('Successfully fetched missed updates')
         except errors.RPCError as e:
             self._log[__name__].warning('Failed to get missed updates after '
                                         'reconnect: %r', e)

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/uploads.py

@@ -699,6 +699,8 @@ class UploadMethods:
             hash_md5 = hashlib.md5()
 
             part_count = (file_size + part_size - 1) // part_size
+            self._log[__name__].debug('Uploading file of %d bytes in %d chunks of %d',
+                                     file_size, part_count, part_size)
 
             pos = 0
             for part_index in range(part_count):
@@ -740,6 +742,8 @@ class UploadMethods:
 
                 result = await self(request)
                 if result:
+                    self._log[__name__].debug('Uploaded %d/%d',
+                                              part_index + 1, part_count)
                     if progress_callback:
                         await helpers._maybe_await(progress_callback(pos, file_size))
                 else:

{spluspy-2.1.6 → spluspy-2.1.7}/spluspy/_engine/client/users.py

@@ -54,6 +54,7 @@ class UserMethods:
                 if diff <= 3:  # Flood waits below 3 seconds are "ignored"
                     self._flood_waited_requests.pop(r.CONSTRUCTOR_ID, None)
                 elif diff <= flood_sleep_threshold:
+                    self._log[__name__].debug(*_fmt_flood(diff, r, early=True))
                     await asyncio.sleep(diff)
                     self._flood_waited_requests.pop(r.CONSTRUCTOR_ID, None)
                 else:
@@ -124,12 +125,14 @@ class UserMethods:
                     e.seconds = 1
 
                 if e.seconds <= self.flood_sleep_threshold:
+                    self._log[__name__].debug(*_fmt_flood(e.seconds, request))
                     await asyncio.sleep(e.seconds)
                 else:
                     raise
             except (errors.PhoneMigrateError, errors.NetworkMigrateError,
                     errors.UserMigrateError) as e:
                 last_error = e
+                self._log[__name__].debug('Phone migrated to %d', e.new_dc)
                 should_raise = isinstance(e, (
                     errors.PhoneMigrateError, errors.NetworkMigrateError
                 ))
@@ -178,6 +181,7 @@ class UserMethods:
 
             return utils.get_input_peer(me, allow_self=False) if input_peer else me
         except errors.UnauthorizedError as e:
+            _log.debug('Not authorized to get self user: %s', e)
             return None
 
     @property
@@ -225,6 +229,7 @@ class UserMethods:
                 await self(functions.updates.GetStateRequest())
                 self._authorized = True
             except errors.RPCError as e:
+                _log.debug('Authorization check failed: %s', e)
                 self._authorized = False
             except Exception:
                 raise
@@ -311,7 +316,7 @@ class UserMethods:
             try:
                 lists[helpers._entity_type(x)].append(x)
             except TypeError as e:
-                pass
+                _log.debug('Could not determine entity type for %s: %s', x, e)
 
         users = lists[helpers._EntityType.USER]
         chats = lists[helpers._EntityType.CHAT]
@@ -424,7 +429,7 @@ class UserMethods:
         try:
             return utils.get_input_peer(peer)
         except TypeError as e:
-            pass
+            _log.debug('Could not convert peer to input_peer: %s', e)
 
         # Next in priority is having a peer (or its ID) cached in-memory
         try:
@@ -432,7 +437,7 @@ class UserMethods:
             if isinstance(peer, int) or peer.SUBCLASS_OF_ID == 0x2d45687:
                 return self._mb_entity_cache.get(utils.get_peer_id(peer, add_mark=False))._as_input_peer()
         except AttributeError as e:
-            pass
+            _log.debug('Could not get input entity from cache: %s', e)
 
         # Then come known strings that take precedence
         if peer in ('me', 'self'):
@@ -443,7 +448,7 @@ class UserMethods:
             input_entity = await utils.maybe_async(self.session.get_input_entity(peer))
             return input_entity
         except ValueError as e:
-            pass
+            _log.debug('Entity not found in session: %s', e)
 
         # Only network left to try
         if isinstance(peer, str):
@@ -475,7 +480,7 @@ class UserMethods:
                     types.InputChannel(peer.channel_id, access_hash=0)]))
                 return utils.get_input_peer(channels.chats[0])
             except errors.ChannelInvalidError as e:
-                pass
+                _log.debug('Channel invalid: %s', e)
 
         raise ValueError(
             'Could not find the input entity for {} ({}). Please read https://'
@@ -514,6 +519,7 @@ class UserMethods:
                 # 0x2d45687, 0xc91c90b6 == crc32(b'Peer') and b'InputPeer'
                 peer = await self.get_input_entity(peer)
         except AttributeError as e:
+            _log.debug('Peer has no SUBCLASS_OF_ID: %s', e)
             peer = await self.get_input_entity(peer)
 
         if isinstance(peer, types.InputPeerSelf):
@@ -577,13 +583,13 @@ class UserMethods:
                     else:
                         return next(x for x in result.chats if x.id == pid)
                 except StopIteration as e:
-                    pass
+                    _log.debug('Entity not found in resolve result: %s', e)
             try:
                 # Nobody with this username, maybe it's an exact name/title
                 input_entity = await utils.maybe_async(self.session.get_input_entity(string))
                 return await self.get_entity(input_entity)
             except ValueError as e:
-                pass
+                _log.debug('Entity not found by name: %s', e)
 
         raise ValueError(
             'Cannot find any entity corresponding to "{}"'.format(string)
@@ -602,7 +608,7 @@ class UserMethods:
             elif dialog.SUBCLASS_OF_ID == 0xc91c90b6:  # crc32(b'InputPeer')
                 return types.InputDialogPeer(dialog)
         except AttributeError as e:
-            pass
+            _log.debug('Dialog has no SUBCLASS_OF_ID: %s', e)
 
         return types.InputDialogPeer(await self.get_input_entity(dialog))
 
@@ -618,7 +624,7 @@ class UserMethods:
                     notify.peer = await self.get_input_entity(notify.peer)
                 return notify
         except AttributeError as e:
-            pass
+            _log.debug('Notify has no SUBCLASS_OF_ID: %s', e)
 
         return types.InputNotifyPeer(await self.get_input_entity(notify))