def get_dialogs_count(self, pinned_only: bool = False) -> int: """Get the total count of your dialogs. pinned_only (``bool``, *optional*): Pass True if you want to count only pinned dialogs. Defaults to False. Returns: ``int``: On success, the dialogs count is returned. Raises: RPCError: In case of a Telegram RPC error. """ if pinned_only: return len( self.send( functions.messages.GetPinnedDialogs(folder_id=0)).dialogs) else: r = self.send( functions.messages.GetDialogs( offset_date=0, offset_id=0, offset_peer=types.InputPeerEmpty(), limit=1, hash=0)) if isinstance(r, types.messages.Dialogs): return len(r.dialogs) else: return r.count
async def get_dialogs_count(self, pinned_only: bool = False) -> int: """Get the total count of your dialogs. pinned_only (``bool``, *optional*): Pass True if you want to count only pinned dialogs. Defaults to False. Returns: ``int``: On success, the dialogs count is returned. Example: .. code-block:: python count = app.get_dialogs_count() print(count) """ if pinned_only: return len((await self.send(functions.messages.GetPinnedDialogs(folder_id=0))).dialogs) else: r = await self.send( functions.messages.GetDialogs( offset_date=0, offset_id=0, offset_peer=types.InputPeerEmpty(), limit=1, hash=0 ) ) if isinstance(r, types.messages.Dialogs): return len(r.dialogs) else: return r.count
def get_dialogs( self, offset_date: int = 0, limit: int = 100, pinned_only: bool = False ) -> "pyrogram.Dialogs": """Get a chunk of the user's dialogs. You can get up to 100 dialogs at once. For a more convenient way of getting a user's dialogs see :meth:`~Client.iter_dialogs`. Parameters: offset_date (``int``): The offset date in Unix time taken from the top message of a :obj:`Dialog`. Defaults to 0. Valid for non-pinned dialogs only. limit (``str``, *optional*): Limits the number of dialogs to be retrieved. Defaults to 100. Valid for non-pinned dialogs only. pinned_only (``bool``, *optional*): Pass True if you want to get only pinned dialogs. Defaults to False. Returns: :obj:`Dialogs`: On success, an object containing a list of dialogs is returned. Raises: RPCError: In case of a Telegram RPC error. """ while True: try: if pinned_only: r = self.send(functions.messages.GetPinnedDialogs(folder_id=0)) else: r = self.send( functions.messages.GetDialogs( offset_date=offset_date, offset_id=0, offset_peer=types.InputPeerEmpty(), limit=limit, hash=0, exclude_pinned=True ) ) except FloodWait as e: log.warning("Sleeping {}s".format(e.x)) time.sleep(e.x) else: break return pyrogram.Dialogs._parse(self, r)
def get_dialogs_chunk(self, offset_date): while True: try: r = self.send( functions.messages.GetDialogs(offset_date, 0, types.InputPeerEmpty(), self.DIALOGS_AT_ONCE, True)) except FloodWait as e: log.warning("get_dialogs flood: waiting {} seconds".format( e.x)) time.sleep(e.x) else: log.info("Total peers: {}".format(len(self.peers_by_id))) return r
def get_initial_dialogs_chunk(self, offset_date: int = 0): while True: try: r = self.send( functions.messages.GetDialogs( offset_date=offset_date, offset_id=0, offset_peer=types.InputPeerEmpty(), limit=self.DIALOGS_AT_ONCE, hash=0, exclude_pinned=True ) ) except FloodWait as e: log.warning("get_dialogs flood: waiting {} seconds".format(e.x)) time.sleep(e.x) else: log.info("Total peers: {}".format(len(self.peers_by_id))) return r
def get_dialogs(self, offset_date: int = 0, limit: int = 100, pinned_only: bool = False) -> "pyrogram.Dialogs": """Use this method to get the user's dialogs You can get up to 100 dialogs at once. Args: offset_date (``int``): The offset date in Unix time taken from the top message of a :obj:`Dialog`. Defaults to 0. Valid for non-pinned dialogs only. limit (``str``, *optional*): Limits the number of dialogs to be retrieved. Defaults to 100. Valid for non-pinned dialogs only. pinned_only (``bool``, *optional*): Pass True if you want to get only pinned dialogs. Defaults to False. Returns: On success, a :obj:`Dialogs` object is returned. Raises: :class:`Error <pyrogram.Error>` in case of a Telegram RPC error. """ if pinned_only: r = self.send(functions.messages.GetPinnedDialogs()) else: r = self.send( functions.messages.GetDialogs( offset_date=offset_date, offset_id=0, offset_peer=types.InputPeerEmpty(), limit=limit, hash=0, exclude_pinned=True)) return pyrogram.Dialogs._parse(self, r)
async def get_dialogs( self, offset_date: int = 0, limit: int = 100, pinned_only: bool = False) -> List["pyrogram.Dialog"]: """Get a chunk of the user's dialogs. You can get up to 100 dialogs at once. For a more convenient way of getting a user's dialogs see :meth:`~Client.iter_dialogs`. Parameters: offset_date (``int``): The offset date in Unix time taken from the top message of a :obj:`Dialog`. Defaults to 0. Valid for non-pinned dialogs only. limit (``str``, *optional*): Limits the number of dialogs to be retrieved. Defaults to 100. Valid for non-pinned dialogs only. pinned_only (``bool``, *optional*): Pass True if you want to get only pinned dialogs. Defaults to False. Returns: List of :obj:`Dialog`: On success, a list of dialogs is returned. Example: .. code-block:: python # Get first 100 dialogs app.get_dialogs() # Get pinned dialogs app.get_dialogs(pinned_only=True) """ while True: try: if pinned_only: r = await self.send( functions.messages.GetPinnedDialogs(folder_id=0)) else: r = await self.send( functions.messages.GetDialogs( offset_date=offset_date, offset_id=0, offset_peer=types.InputPeerEmpty(), limit=limit, hash=0, exclude_pinned=True)) except FloodWait as e: log.warning("Sleeping for {}s".format(e.x)) await asyncio.sleep(e.x) else: break users = {i.id: i for i in r.users} chats = {i.id: i for i in r.chats} messages = {} for message in r.messages: to_id = message.to_id if isinstance(to_id, types.PeerUser): if message.out: chat_id = to_id.user_id else: chat_id = message.from_id else: chat_id = utils.get_peer_id(to_id) messages[chat_id] = await pyrogram.Message._parse( self, message, users, chats) parsed_dialogs = [] for dialog in r.dialogs: if not isinstance(dialog, types.Dialog): continue parsed_dialogs.append( pyrogram.Dialog._parse(self, dialog, messages, users, chats)) return pyrogram.List(parsed_dialogs)
async def search_global( self, query: str, limit: int = 0, ) -> Optional[Generator["pyrogram.Message", None, None]]: """Search messages globally from all of your chats. .. note:: Due to server-side limitations, you can only get up to around ~10,000 messages and each message retrieved will not have any *reply_to_message* field. Parameters: query (``str``): Text query string. limit (``int``, *optional*): Limits the number of messages to be retrieved. By default, no limit is applied and all messages are returned. Returns: ``Generator``: A generator yielding :obj:`Message` objects. Example: .. code-block:: python # Search for "pyrogram". Get the first 420 results for message in app.search_global("pyrogram", limit=420): print(message.text) """ current = 0 # There seems to be an hard limit of 10k, beyond which Telegram starts spitting one message at a time. total = abs(limit) or (1 << 31) limit = min(100, total) offset_date = 0 offset_peer = types.InputPeerEmpty() offset_id = 0 while True: messages = await utils.parse_messages( self, await self.send( functions.messages.SearchGlobal(q=query, offset_rate=offset_date, offset_peer=offset_peer, offset_id=offset_id, limit=limit)), replies=0) if not messages: return last = messages[-1] offset_date = last.date offset_peer = await self.resolve_peer(last.chat.id) offset_id = last.message_id for message in messages: await yield_(message) current += 1 if current >= total: return
def get_dialogs(self, offset_dialogs=None, limit: int = 100, pinned_only: bool = False): """Use this method to get the user's dialogs You can get up to 100 dialogs at once. Args: limit (``str``, *optional*): Limits the number of dialogs to be retrieved. Defaults to 100 pinned_only (``bool``, *optional*): Pass True if you want to get only pinned dialogs. Defaults to False. offset_dialogs (:obj:`Dialogs`): Pass the previous dialogs object to retrieve the next dialogs chunk starting from the last dialog. Defaults to None (start from the beginning). Returns: On success, a :obj:`Dialogs` object is returned. Raises: :class:`Error <pyrogram.Error>` in case of a Telegram RPC error. """ if pinned_only: r = self.send(functions.messages.GetPinnedDialogs()) else: offset_date = 0 if offset_dialogs: for dialog in reversed(offset_dialogs.dialogs): top_message = dialog.top_message if top_message: message_date = top_message.date if message_date: offset_date = message_date break r = self.send( functions.messages.GetDialogs( offset_date=offset_date, offset_id=0, offset_peer=types.InputPeerEmpty(), limit=limit, hash=0, exclude_pinned=True)) users = {i.id: i for i in r.users} chats = {i.id: i for i in r.chats} messages = {} for message in r.messages: to_id = message.to_id if isinstance(to_id, types.PeerUser): if message.out: chat_id = to_id.user_id else: chat_id = message.from_id elif isinstance(to_id, types.PeerChat): chat_id = -to_id.chat_id else: chat_id = int("-100" + str(to_id.channel_id)) messages[chat_id] = utils.parse_messages(self, message, users, chats) dialogs = [] for dialog in r.dialogs: chat_id = dialog.peer if isinstance(chat_id, types.PeerUser): chat_id = chat_id.user_id elif isinstance(chat_id, types.PeerChat): chat_id = -chat_id.chat_id else: chat_id = int("-100" + str(chat_id.channel_id)) dialogs.append( pyrogram.Dialog( chat=utils.parse_dialog_chat(dialog.peer, users, chats), top_message=messages.get(chat_id), unread_messages_count=dialog.unread_count, unread_mentions_count=dialog.unread_mentions_count, unread_mark=dialog.unread_mark, is_pinned=dialog.pinned)) return pyrogram.Dialogs(total_count=getattr(r, "count", len(r.dialogs)), dialogs=dialogs)