spluspy 2.1.4__tar.gz → 2.1.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.1.4
+Version: 2.1.6
 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.4 → spluspy-2.1.6}/pyproject.toml

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

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

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

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

@@ -242,6 +242,5 @@ 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.4 → spluspy-2.1.6}/spluspy/_engine/client/auth.py

@@ -160,7 +160,7 @@ class AuthMethods:
                             'you are accidentally reusing an existing session'
                         )
             except Exception as e:
-                _log.debug('Failed to verify existing session user: %s', e)
+                pass
 
             return self
 
@@ -352,7 +352,6 @@ 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:
@@ -400,7 +399,6 @@ 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)
@@ -421,7 +419,7 @@ class AuthMethods:
                                      int(state.date.timestamp()), state.seq, 0),
                         [])
                 except Exception as e:
-                    _log.debug('Failed to initialize message box during login: %s', e)
+                    pass
                 return None
             raise
 
@@ -537,9 +535,6 @@ 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)
 
@@ -608,7 +603,6 @@ 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.4 → spluspy-2.1.6}/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:
-            _log.debug('Connection error during typing action: %s', e)
+            pass
         except asyncio.CancelledError:
             if self._auto_cancel:
                 await self._client(functions.messages.SetTypingRequest(

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

@@ -467,7 +467,6 @@ 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
@@ -564,7 +563,6 @@ 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.4 → spluspy-2.1.6}/spluspy/_engine/client/downloads.py

@@ -108,12 +108,10 @@ 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()
@@ -125,7 +123,6 @@ 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)
 
@@ -586,7 +583,6 @@ 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,
@@ -754,12 +750,8 @@ 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,
@@ -1064,7 +1056,6 @@ 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.4 → spluspy-2.1.6}/spluspy/_engine/client/messages.py

@@ -311,7 +311,6 @@ 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.4 → spluspy-2.1.6}/spluspy/_engine/client/telegrambaseclient.py

@@ -394,6 +394,7 @@ 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
 
@@ -574,7 +575,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:
-            _base_log.debug('Could not load self user from session: %s', e)
+            pass
 
         if self._catch_up:
             ss = SessionState(0, 0, False, 0, 0, 0, 0, None)
@@ -610,7 +611,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.
-            _base_log.debug('Ignored config parse error during init: %s', e)
+            pass
 
         # Don't call get_me() here — on Soroush the auth key is not
         # registered until after login, and GetUsersRequest (used by
@@ -671,7 +672,7 @@ class SoroushPlusBaseClient(abc.ABC):
                 #   "Event loop stopped before Future completed."
                 #
                 # However, it doesn't really make a lot of sense.
-                _base_log.debug('RuntimeError during disconnect: %s', e)
+                pass
 
     def set_proxy(self: 'SoroushClient', proxy: typing.Union[tuple, dict]):
         """
@@ -774,7 +775,6 @@ 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,7 +884,6 @@ 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)
@@ -900,7 +899,6 @@ 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:
@@ -929,7 +927,6 @@ 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()
 
@@ -940,8 +937,6 @@ 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()
@@ -956,7 +951,6 @@ 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.4 → spluspy-2.1.6}/spluspy/_engine/client/updates.py

@@ -4,7 +4,6 @@ import itertools
 import random
 import sys
 import time
-import traceback
 import typing
 import logging
 import warnings
@@ -284,14 +283,11 @@ class UpdateMethods:
                     if self._sequential_updates:
                         await self._dispatch_update(updates_to_dispatch.popleft())
                     else:
-                        # 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)
+                        # 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)
 
                     continue
 
@@ -299,7 +295,6 @@ 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 (
@@ -309,12 +304,10 @@ 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
@@ -341,21 +334,16 @@ 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:
@@ -426,10 +414,6 @@ 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,
@@ -450,10 +434,6 @@ 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,
@@ -463,9 +443,6 @@ 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
@@ -498,7 +475,6 @@ 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
@@ -649,6 +625,7 @@ 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:
@@ -663,32 +640,27 @@ class UpdateMethods:
             if not filter:
                 continue
 
-            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 _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)
 
     async def _dispatch_event(self: 'SoroushClient', event):
         """
         Dispatches a single, out-of-order event. Used by `AlbumHack`.
         """
-        # 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.
+        tasks = []
         for builder, callback in self._event_builders:
             if isinstance(builder, events.Raw):
                 continue
@@ -704,24 +676,21 @@ class UpdateMethods:
             if not filter:
                 continue
 
-            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 _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)
 
     async def _handle_auto_reconnect(self: 'SoroushClient'):
         # Use lightweight get_me to let SoroushPlus know we want updates
@@ -732,15 +701,12 @@ 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.4 → spluspy-2.1.6}/spluspy/_engine/client/uploads.py

@@ -699,8 +699,6 @@ 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):
@@ -742,8 +740,6 @@ 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.4 → spluspy-2.1.6}/spluspy/_engine/client/users.py

@@ -54,7 +54,6 @@ 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:
@@ -125,14 +124,12 @@ 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
                 ))
@@ -181,7 +178,6 @@ 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
@@ -229,7 +225,6 @@ 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
@@ -316,7 +311,7 @@ class UserMethods:
             try:
                 lists[helpers._entity_type(x)].append(x)
             except TypeError as e:
-                _log.debug('Could not determine entity type for %s: %s', x, e)
+                pass
 
         users = lists[helpers._EntityType.USER]
         chats = lists[helpers._EntityType.CHAT]
@@ -429,7 +424,7 @@ class UserMethods:
         try:
             return utils.get_input_peer(peer)
         except TypeError as e:
-            _log.debug('Could not convert peer to input_peer: %s', e)
+            pass
 
         # Next in priority is having a peer (or its ID) cached in-memory
         try:
@@ -437,7 +432,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:
-            _log.debug('Could not get input entity from cache: %s', e)
+            pass
 
         # Then come known strings that take precedence
         if peer in ('me', 'self'):
@@ -448,7 +443,7 @@ class UserMethods:
             input_entity = await utils.maybe_async(self.session.get_input_entity(peer))
             return input_entity
         except ValueError as e:
-            _log.debug('Entity not found in session: %s', e)
+            pass
 
         # Only network left to try
         if isinstance(peer, str):
@@ -480,7 +475,7 @@ class UserMethods:
                     types.InputChannel(peer.channel_id, access_hash=0)]))
                 return utils.get_input_peer(channels.chats[0])
             except errors.ChannelInvalidError as e:
-                _log.debug('Channel invalid: %s', e)
+                pass
 
         raise ValueError(
             'Could not find the input entity for {} ({}). Please read https://'
@@ -519,7 +514,6 @@ 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):
@@ -583,13 +577,13 @@ class UserMethods:
                     else:
                         return next(x for x in result.chats if x.id == pid)
                 except StopIteration as e:
-                    _log.debug('Entity not found in resolve result: %s', e)
+                    pass
             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:
-                _log.debug('Entity not found by name: %s', e)
+                pass
 
         raise ValueError(
             'Cannot find any entity corresponding to "{}"'.format(string)
@@ -608,7 +602,7 @@ class UserMethods:
             elif dialog.SUBCLASS_OF_ID == 0xc91c90b6:  # crc32(b'InputPeer')
                 return types.InputDialogPeer(dialog)
         except AttributeError as e:
-            _log.debug('Dialog has no SUBCLASS_OF_ID: %s', e)
+            pass
 
         return types.InputDialogPeer(await self.get_input_entity(dialog))
 
@@ -624,7 +618,7 @@ class UserMethods:
                     notify.peer = await self.get_input_entity(notify.peer)
                 return notify
         except AttributeError as e:
-            _log.debug('Notify has no SUBCLASS_OF_ID: %s', e)
+            pass
 
         return types.InputNotifyPeer(await self.get_input_entity(notify))