U hE@sddlZddlZddlZddlZddlmZmZmZmZddl m Z ddl m Z m Z dZejrjddlmZGd d d e ZGd d d e ZGd ddZdS)N)helpersutilserrorshints) RequestIter)types functionsd)TelegramClientc@s0eZdZdZddZddZddZdd Zd S) _MessagesIterzL Common factor for all requests that need to iterate over messages. c s,|r|j|IdH|_nd|_|jr.td|jrdt||}|rV|rV||dkrVt|std}n"t||}|r|r||dkrt|jr|r|d7}n|sd}|r|j|IdH}|j|IdH|_ nd|_ |js|rt |_|dkrt }nt |tr |n|}|jsDtjj| p&d|d|dt |dd|_n2| r`tjj|dd|_n| dk rtjj|j| |||ddddd |_n| dk st |t j r|rVt|j} | tjjkrd}nd|_ tjj|j| pd|d|||dddd|d |_t |t j sv|rv| sv|sv|jj|jd|d 2z3dHW} | jd|j_q46n tjj|jd||dd|dd |_|jdkr||jIdH}t |t jjr|j |_!nt"|d t#|j|_!t|j$dkr|jd krdnd|_$|jr|jj%t&8_%||_%||_'||_(|jrdntd|_)dS)NzCannot reverse global searchr infr)qfiltermin_datemax_date offset_rate offset_peer offset_idlimit)peerhash) rmsg_idr offset_date add_offsetrmax_idmin_idr) rrrrrrrrrrrfrom_id)r)rrrrrrrrcounti )*clientget_input_entityentityreverse ValueErrormaxStopAsyncIterationfloat get_peer_idrrInputPeerEmptyZInputMessagesFilterEmpty isinstancetyper messagesSearchGlobalRequestrequestZGetScheduledHistoryRequestZGetRepliesRequestr _entity_type _EntityTypeUSER SearchRequest iter_messagesidrZGetHistoryRequestrMessagesNotModifiedr totalgetattrlen wait_timer_MAX_CHUNK_SIZErrlast_id)selfr#rrr from_userrrrsearchreply_to scheduledtymresultrEsz2_MessagesIter._load_next_chunk..Tr)minleftr;r/rr$rr!r8r9r-r7 itertoolschainuserschatsreversedr+r MessageEmptyrZ sender_id_message_in_ranger5r< _finish_initr#bufferappendZMessages_update_offset)r=rentitiesr-messagerErErF_load_next_chunks8   &z_MessagesIter._load_next_chunkcCsJ|jrF|jr*|j|jks$|j|jkrFdSn|j|jksB|j|jkrFdSdS)z Determine whether the given message is in the range or it should be ignored (and avoid loading more chunks). FT)r#r$r5r<rr)r=r]rErErFrVsz_MessagesIter._message_in_rangecCs|j|j_|jr |jjd7_t|jtjjr:d|j_n |j |j_ t|jtjj r|j rf|j |j_ n t|j_ t|dd|j_dS)zT After making the request, update its offset with the last message. r NZ next_rater)r5r/rr$r+r r-r3rdaterr.Z input_chatrrr*r8r)r=Z last_messageresponserErErFrZs     z_MessagesIter._update_offsetN)__name__ __module__ __qualname____doc__rGr^rVrZrErErErFr s >r c@seZdZddZddZdS)_IDsItercs~t||_|jrtt|n||_d|_|r>|j|IdHnd|_ |j rVt |j nd|_ |j dkrz|jdkrtdnd|_ dS)Nri, )r9r7r$listrT_ids_offsetr!r"_entityrr0_tyr:r)r=r#idsrErErFrGs  z_IDsIter._initcsZ|j|j|jt}|st|jt7_d}|jtjjkrz |t j |j |IdH}Wqt jk rtjt|}YqXn2|t j |IdH}|j r|j|j IdH}t|tjjr|jdd|DdSddt|j|jD}|jD]R}t|tjs&|r4|j|kr4|jdn||j||j |j|qdS)Ncss|] }dVqdSNrE)rJ_rErErF =sz,_IDsIter._load_next_chunk..cSsi|]}t||qSrErHrIrErErFrL@sz-_IDsIter._load_next_chunk..)rhrir;r'rkrr1CHANNELr!r channelsZGetMessagesRequestrjrZMessageIdsEmptyErrorrr-r6r9 _get_peerr+rXextendrPrQrRrSrUpeer_idrYrW)r=rlrr[r\r]rErErFr^(s< z_IDsIter._load_next_chunkN)rarbrcrGr^rErErErFres rec@s<eZdZdCdddddddddddddd ddedeeeeedded eeed d d d Zdej dej dfdddZ e ee _ddddddZdDddddddddddddddddddddddddej eej ejejeddeeej deeeddeej dej edd d!d"ZdEdddddddd#ddd$deeeedeed%d& d'd(ZdFddddddddddd) dd*d+eedej ejejeddeej deddd,d-d.Zdd/ddd$ed0d1d2d3ZdGdddd4ddd$eeeed5d6d7Zddd8ddd9eed:d;d<ZdHdd=ddd9ed>d?d@Zddd8dAdBZdS)IMessageMethodsNrF) rrrrrr?rr>r:rlr$r@rAr zhints.EntityLikezhints.DateLikezMtyping.Union[types.TypeMessagesFilter, typing.Type[types.TypeMessagesFilter]]z'typing.Union[int, typing.Sequence[int]]z%typing.Union[_MessagesIter, _IDsIter])r=r#rrrrrrr?rr>r:rlr$r@rAreturnc CsV| dk r0t| s| g} t|| | t| || dSt|| | |||||| ||| |||dS)a Iterator over the messages for the given chat. The default order is from newest to oldest, but this behaviour can be changed with the `reverse` parameter. If either `search`, `filter` or `from_user` are provided, :tl:`messages.Search` will be used instead of :tl:`messages.getHistory`. .. note:: Telegram's flood wait limit for :tl:`GetHistoryRequest` seems to be around 30 seconds per 10 requests, therefore a sleep of 1 second is the default for this limit (or above). Arguments entity (`entity`): The entity from whom to retrieve the message history. It may be `None` to perform a global search, or to get messages by their ID from no particular chat. Note that some of the offsets will not work if this is the case. Note that if you want to perform a global search, you **must** set a non-empty `search` string, a `filter`. or `from_user`. limit (`int` | `None`, optional): Number of messages to be retrieved. Due to limitations with the API retrieving more than 3000 messages will take longer than half a minute (or even more based on previous calls). The limit may also be `None`, which would eventually return the whole history. offset_date (`datetime`): Offset date (messages *previous* to this date will be retrieved). Exclusive. offset_id (`int`): Offset message ID (only messages *previous* to the given ID will be retrieved). Exclusive. max_id (`int`): All the messages with a higher (newer) ID or equal to this will be excluded. min_id (`int`): All the messages with a lower (older) ID or equal to this will be excluded. add_offset (`int`): Additional message offset (all of the specified offsets + this offset = older messages). search (`str`): The string to be used as a search query. filter (:tl:`MessagesFilter` | `type`): The filter to use when returning messages. For instance, :tl:`InputMessagesFilterPhotos` would yield only messages containing photos. from_user (`entity`): Only messages from this entity will be returned. wait_time (`int`): Wait time (in seconds) between different :tl:`GetHistoryRequest`. Use this parameter to avoid hitting the ``FloodWaitError`` as needed. If left to `None`, it will default to 1 second only if the limit is higher than 3000. If the ``ids`` parameter is used, this time will default to 10 seconds only if the amount of IDs is higher than 300. ids (`int`, `list`): A single integer ID (or several IDs) for the message that should be returned. This parameter takes precedence over the rest (which will be ignored if this is set). This can for instance be used to get the message with ID 123 from a channel. Note that if the message doesn't exist, `None` will appear in its place, so that zipping the list of IDs with the messages can match one-to-one. .. note:: At the time of writing, Telegram will **not** return :tl:`MessageEmpty` for :tl:`InputMessageReplyTo` IDs that failed (i.e. the message is not replying to any, or is replying to a deleted message). This means that it is **not** possible to match messages one-by-one, so be careful if you use non-integers in this parameter. reverse (`bool`, optional): If set to `True`, the messages will be returned in reverse order (from oldest to newest, instead of the default newest to oldest). This also means that the meaning of `offset_id` and `offset_date` parameters is reversed, although they will still be exclusive. `min_id` becomes equivalent to `offset_id` instead of being `max_id` as well since messages are returned in ascending order. You cannot use this if both `entity` and `ids` are `None`. reply_to (`int`, optional): If set to a message ID, the messages that reply to this ID will be returned. This feature is also known as comments in posts of broadcast channels, or viewing threads in groups. This feature can only be used in broadcast channels and their linked megagroups. Using it in a chat or private conversation will result in ``telethon.errors.PeerIdInvalidError`` to occur. When using this parameter, the ``filter`` and ``search`` parameters have no effect, since Telegram's API doesn't support searching messages in replies. .. note:: This feature is used to get replies to a message in the *discussion* group. If the same broadcast channel sends a message and replies to it itself, that reply will not be included in the results. scheduled (`bool`, optional): If set to `True`, messages which are scheduled will be returned. All other parameter will be ignored for this, except `entity`. Yields Instances of `Message `. Example .. code-block:: python # From most-recent to oldest async for message in client.iter_messages(chat): print(message.id, message.text) # From oldest to most-recent async for message in client.iter_messages(chat, reverse=True): print(message.id, message.text) # Filter by sender async for message in client.iter_messages(chat, from_user='me'): print(message.text) # Server-side search with fuzzy text async for message in client.iter_messages(chat, search='hello'): print(message.id) # Filter by message type: from telethon.tl.types import InputMessagesFilterPhotos async for message in client.iter_messages(chat, filter=InputMessagesFilterPhotos): print(message.photo) # Getting comments from a post in a channel: async for message in client.iter_messages(channel, reply_to=123): print(message.chat.title, message.text) N)r!r$r:rr#rl)r!r$r:rr#rrrr>rrrr?r@rA)r is_list_likerer9r )r=r#rrrrrrr?rr>r:rlr$r@rArErErFr4Zs:4  zMessageMethods.iter_messageszhints.TotalListz types.Message)r=rvcst|dkr6d|kr6d|kr.d|kr.d|d<nd|d<|j||}|d}|rxt|sx|2z3dHW}|S6dS|IdHS)a' Same as `iter_messages()`, but returns a `TotalList ` instead. If the `limit` is not set, it will be 1 by default unless both `min_id` **and** `max_id` are set (as *named* arguments), in which case the entire range will be returned. This is so because any integer limit would be rather arbitrary and it's common to only want to fetch one message, but if a range is specified it makes sense that it should return the entirety of it. If `ids` is present in the *named* arguments and is not a list, a single `Message ` will be returned for convenience instead of a list. Example .. code-block:: python # Get 0 photos and print the total to show how many photos there are from telethon.tl.types import InputMessagesFilterPhotos photos = await client.get_messages(chat, 0, filter=InputMessagesFilterPhotos) print(photos.total) # Get all the photos photos = await client.get_messages(chat, None, filter=InputMessagesFilterPhotos) # Get messages by ID: message_1337 = await client.get_messages(chat, ids=1337) r rrrNrl)r9r4getrrwZcollect)r=argskwargsitrlr]rErErF get_messages,s!    zMessageMethods.get_messagesz typing.Union[int, types.Message])r=r#r]csZ|tjj|t|dIdH}t|jdddtfdd|jD}t|j fS)N)rrcSs|jSrmr5)msgrErErFnz2MessageMethods._get_comment_data..keyc3s |]}|jjjkr|VqdSrm)r5rtZ channel_idrJcrCrErFroosz3MessageMethods._get_comment_data..) r r-ZGetDiscussionMessageRequestrget_message_idrNnextrSZget_input_peerr5)r=r#r]r[chatrErrF_get_comment_dataesz MessageMethods._get_comment_datarrET)r@ attributes parse_modeformatting_entities link_previewfilethumbforce_document clear_draftbuttonssilent backgroundsupports_streamingschedule comment_to nosound_videosend_asmessage_effect_idzhints.MessageLikez,typing.Sequence[types.TypeDocumentAttribute]z=typing.Union[hints.FileLike, typing.Sequence[hints.FileLike]]zhints.FileLikezhints.MarkupLike)r=r#r]r@rrrrrrrrrrrrrrrrrrvcsv|dk rZt|tjr$|p|j}|j}|j||||||| | | | | ||||||||dIdHS||IdH}|dk r|||IdH\}}n t |}t|tjr|| dkr|j }n | | }| dkr|j } |j rt|j tjs|j||j |j| ||||jd|||d IdHStjj||jp"d| ||dkr4dnt|||j| t|j tj ||rj||IdHnd|d }|j}n|dkr|||IdH\}}|stdtjj|||| |dkrdnt|| | || | ||r||IdHnd|d }||IdH}t|tjrhtj|j||IdH||j|j|j |j|j |j|jd }||i||S||||S) a% Sends a message to the specified user, chat or channel. The default parse mode is the same as the official applications (a custom flavour of markdown). ``**bold**, `code` or __italic__`` are available. In addition you can send ``[links](https://example.com)`` and ``[mentions](@username)`` (or using IDs like in the Bot API: ``[mention](tg://user?id=123456789)``) and ``pre`` blocks with three backticks. Sending a ``/start`` command with a parameter (like ``?start=data``) is also done through this method. Simply send ``'/start data'`` to the bot. See also `Message.respond() ` and `Message.reply() `. Arguments entity (`entity`): To who will it be sent. message (`str` | `Message `): The message to be sent, or another message object to resend. The maximum length for a message is 35,000 bytes or 4,096 characters. Longer messages will not be sliced automatically, and you should slice them manually if the text to send is longer than said length. reply_to (`int` | `Message `, optional): Whether to reply to a message or not. If an integer is provided, it should be the ID of the message that it should reply to. attributes (`list`, optional): Optional attributes that override the inferred ones, like :tl:`DocumentAttributeFilename` and so on. parse_mode (`object`, optional): See the `TelegramClient.parse_mode ` property for allowed values. Markdown parsing will be used by default. formatting_entities (`list`, optional): A list of message formatting entities. When provided, the ``parse_mode`` is ignored. link_preview (`bool`, optional): Should the link preview be shown? file (`file`, optional): Sends a message with a file attached (e.g. a photo, video, audio or document). The ``message`` may be empty. thumb (`str` | `bytes` | `file`, optional): Optional JPEG thumbnail (for documents). **Telegram will ignore this parameter** unless you pass a ``.jpg`` file! The file must also be small in dimensions and in disk size. Successful thumbnails were files below 20kB and 320x320px. Width/height and dimensions/size ratios may be important. For Telegram to accept a thumbnail, you must provide the dimensions of the underlying media through ``attributes=`` with :tl:`DocumentAttributesVideo` or by installing the optional ``hachoir`` dependency. force_document (`bool`, optional): Whether to send the given file as a document or not. clear_draft (`bool`, optional): Whether the existing draft should be cleared or not. buttons (`list`, `custom.Button `, :tl:`KeyboardButton`): The matrix (list of lists), row list or button to be shown after sending the message. This parameter will only work if you have signed in as a bot. You can also pass your own :tl:`ReplyMarkup` here. All the following limits apply together: * There can be 100 buttons at most (any more are ignored). * There can be 8 buttons per row at most (more are ignored). * The maximum callback data per button is 64 bytes. * The maximum data that can be embedded in total is just over 4KB, shared between inline callback data and text. silent (`bool`, optional): Whether the message should notify people in a broadcast channel or not. Defaults to `False`, which means it will notify them. Set it to `True` to alter this behaviour. background (`bool`, optional): Whether the message should be send in background. supports_streaming (`bool`, optional): Whether the sent video supports streaming or not. Note that Telegram only recognizes as streamable some formats like MP4, and others like AVI or MKV will not work. You should convert these to MP4 before sending if you want them to be streamable. Unsupported formats will result in ``VideoContentTypeError``. schedule (`hints.DateLike`, optional): If set, the message won't send immediately, and instead it will be scheduled to be automatically sent at a later time. comment_to (`int` | `Message `, optional): Similar to ``reply_to``, but replies in the linked group of a broadcast channel instead (effectively leaving a "comment to" the specified message). This parameter takes precedence over ``reply_to``. If there is no linked chat, `telethon.errors.sgIdInvalidError` is raised. nosound_video (`bool`, optional): Only applicable when sending a video file without an audio track. If set to ``True``, the video will be displayed in Telegram as a video. If set to ``False``, Telegram will attempt to display the video as an animated gif. (It may still display as a video due to other factors.) The value is ignored if set on non-video files. This is set to ``True`` for albums, as gifs cannot be sent in albums. send_as (`entity`): Unique identifier (int) or username (str) of the chat or channel to send the message as. You can use this to send the message on behalf of a chat or channel where you have appropriate permissions. Use the GetSendAs to return the list of message sender identifiers, which can be used to send messages in the chat, This setting applies to the current message and will remain effective for future messages unless explicitly changed. To set this behavior permanently for all messages, use SaveDefaultSendAs. message_effect_id (`int`, optional): Unique identifier of the message effect to be added to the message; for private chats only Returns The sent `custom.Message `. Example .. code-block:: python # Markdown is the default await client.send_message('me', 'Hello **world**!') # Default to another parse mode client.parse_mode = 'html' await client.send_message('me', 'Some bold and italic text') await client.send_message('me', 'An URL') # code and pre tags also work, but those break the documentation :) await client.send_message('me', 'Mentions') # Explicit parse mode # No parse mode by default client.parse_mode = None # ...but here I want markdown await client.send_message('me', 'Hello, **world**!', parse_mode='md') # ...and here I need HTML await client.send_message('me', 'Hello, world!', parse_mode='html') # If you logged in as a bot account, you can send buttons from telethon import events, Button @client.on(events.CallbackQuery) async def callback(event): await event.edit('Thank you for clicking {}!'.format(event.data)) # Single inline button await client.send_message(chat, 'A single button, with "clk1" as data', buttons=Button.inline('Click me', b'clk1')) # Matrix of inline buttons await client.send_message(chat, 'Pick one from this grid', buttons=[ [Button.inline('Left'), Button.inline('Right')], [Button.url('Check this site!', 'https://example.com')] ]) # Reply keyboard await client.send_message(chat, 'Welcome', buttons=[ Button.text('Thanks!', resize=True, single_use=True), Button.request_phone('Send phone'), Button.request_location('Send location') ]) # Forcing replies or clearing buttons. await client.send_message(chat, 'Reply to me', buttons=Button.force_reply()) await client.send_message(chat, 'Bye Keyboard!', buttons=Button.clear()) # Scheduling a message to be sent after 5 minutes from datetime import timedelta await client.send_message(chat, 'Hi, future!', schedule=timedelta(minutes=5)) N)captionr@rrrrrrrrrrrrrrr) rrrr@rrrrrrr) rr]rrr@ reply_markupr\r no_webpage schedule_datereffectz5The message cannot be empty unless a file is provided) rr]r\rr@rrrrrrr) r5rtr]r_outmediar\r ttl_periodr@)r+rMessager\r]Z send_filer"rrrrbuild_reply_markuprrZMessageMediaWebPager r-ZSendMessageRequestZInputReplyToMessage_parse_message_textr%ZUpdateShortSentMessager5rrr_rrr@rW_get_response_message)r=r#r]r@rrrrrrrrrrrrrrrrrZmarkupr/rDrErErF send_messagersW          zMessageMethods.send_message)r with_my_scoreras_albumr drop_authordrop_media_captionszGtyping.Union[hints.MessageIDLike, typing.Sequence[hints.MessageIDLike]]ztyping.Sequence[types.Message]) r=r#r- from_peerrrrrrrrrvc s |dk rtdt| } | r(|f}||IdH}|r^||IdH}||IdHndfdd} g} tj|| dD]\}}t|}t |dt r|}n(|p||dj IdH}dd|D}t j j|||||||| | d }||IdH}| ||||q| r| dS| S) a Forwards the given messages to the specified entity. If you want to "forward" a message without the forward header (the "forwarded from" text), you should use `send_message` with the original message instead. This will send a copy of it. See also `Message.forward_to() `. Arguments entity (`entity`): To which entity the message(s) will be forwarded. messages (`list` | `int` | `Message `): The message(s) to forward, or their integer IDs. from_peer (`entity`): If the given messages are integer IDs and not instances of the ``Message`` class, this *must* be specified in order for the forward to work. This parameter indicates the entity from which the messages should be forwarded. silent (`bool`, optional): Whether the message should notify people with sound or not. Defaults to `False` (send with a notification sound unless the person has the chat muted). Set it to `True` to alter this behaviour. background (`bool`, optional): Whether the message should be forwarded in background. with_my_score (`bool`, optional): Whether forwarded should contain your game score. as_album (`bool`, optional): This flag no longer has any effect. schedule (`hints.DateLike`, optional): If set, the message(s) won't forward immediately, and instead they will be scheduled to be automatically sent at a later time. drop_author (`bool`, optional): Whether to forward messages without quoting the original author. drop_media_captions (`bool`, optional): Whether to strip captions from media. Setting this to `True` requires that `drop_author` also be set to `True`. Returns The list of forwarded `Message `, or a single one if a list wasn't provided as input. Note that if all messages are invalid (i.e. deleted) the call will fail with ``MessageIdInvalidError``. If only some are invalid, the list will have `None` instead of those messages. Example .. code-block:: python # a single one await client.forward_messages(chat, message) # or await client.forward_messages(chat, message_id, from_chat) # or await message.forward_to(chat) # multiple await client.forward_messages(chat, messages) # or await client.forward_messages(chat, message_ids, from_chat) # Forwarding as a copy await client.send_message(chat, message) Nz@the as_album argument is deprecated and no longer has any effectcsHt|tr dk rStdn$t|tjr2|jStdt|dS)Nz/from_peer must be given if integer IDs are usedz"Cannot forward messages of type {}) r+intr%rrZchat_id TypeErrorformatr,rZ from_peer_idrErFget_keys   z0MessageMethods.forward_messages..get_keyrrcSsg|] }|jqSrEr}rJrCrErErF *sz3MessageMethods.forward_messages..) rr5Zto_peerrrrrrr)warningswarnrrwr"r)rPgroupbyrgr+rrtr r-ZForwardMessagesRequestrsr)r=r#r-rrrrrrrrZsinglersentZ_chat_idchunkrreqrDrErrFforward_messagess@X    zMessageMethods.forward_messages) rrrrrrrrrrz-typing.Union[hints.EntityLike, types.Message]z;typing.Union[int, types.Message, types.InputMessageID, str])r=r#r]textrrrrrrrrrrrvc  sbt|tjtjfr |p|}|}nt|tjr:|}|}|j}|dkrX|||IdH\}}|j|| | || dIdH\}}}t|tjtjfr tj j ||| ||| | d}|j j |j k}|rz(||j IdH}|||IdHWS||IdHXn||IdHS||IdH}tj j|t||| ||| | | d}||||IdH|}|S)a Edits the given message to change its text or media. See also `Message.edit() `. Arguments entity (`entity` | `Message `): From which chat to edit the message. This can also be the message to be edited, and the entity will be inferred from it, so the next parameter will be assumed to be the message text. You may also pass a :tl:`InputBotInlineMessageID` or :tl:`InputBotInlineMessageID64`, which is the only way to edit messages that were sent after the user selects an inline query result. message (`int` | `Message ` | :tl:`InputMessageID` | `str`): The ID of the message (or `Message ` itself) to be edited. If the `entity` was a `Message `, then this message will be treated as the new text. text (`str`, optional): The new text of the message. Does nothing if the `entity` was a `Message `. parse_mode (`object`, optional): See the `TelegramClient.parse_mode ` property for allowed values. Markdown parsing will be used by default. attributes (`list`, optional): Optional attributes that override the inferred ones, like :tl:`DocumentAttributeFilename` and so on. formatting_entities (`list`, optional): A list of message formatting entities. When provided, the ``parse_mode`` is ignored. link_preview (`bool`, optional): Should the link preview be shown? file (`str` | `bytes` | `file` | `media`, optional): The file object that should replace the existing media in the message. thumb (`str` | `bytes` | `file`, optional): Optional JPEG thumbnail (for documents). **Telegram will ignore this parameter** unless you pass a ``.jpg`` file! The file must also be small in dimensions and in disk size. Successful thumbnails were files below 20kB and 320x320px. Width/height and dimensions/size ratios may be important. For Telegram to accept a thumbnail, you must provide the dimensions of the underlying media through ``attributes=`` with :tl:`DocumentAttributesVideo` or by installing the optional ``hachoir`` dependency. force_document (`bool`, optional): Whether to send the given file as a document or not. buttons (`list`, `custom.Button `, :tl:`KeyboardButton`): The matrix (list of lists), row list or button to be shown after sending the message. This parameter will only work if you have signed in as a bot. You can also pass your own :tl:`ReplyMarkup` here. supports_streaming (`bool`, optional): Whether the sent video supports streaming or not. Note that Telegram only recognizes as streamable some formats like MP4, and others like AVI or MKV will not work. You should convert these to MP4 before sending if you want them to be streamable. Unsupported formats will result in ``VideoContentTypeError``. schedule (`hints.DateLike`, optional): If set, the message won't be edited immediately, and instead it will be scheduled to be automatically edited at a later time. Note that this parameter will have no effect if you are trying to edit a message that was sent via inline bots. Returns The edited `Message `, unless `entity` was a :tl:`InputBotInlineMessageID` or :tl:`InputBotInlineMessageID64` in which case this method returns a boolean. Raises ``MessageAuthorRequiredError`` if you're not the author of the message but tried editing it anyway. ``MessageNotModifiedError`` if the contents of the message were not modified at all. ``MessageIdInvalidError`` if the ID of the message is invalid (the ID itself may be correct, but the message with that ID cannot be edited). For example, when trying to edit messages with a reply markup (or clear markup) this error will be raised. Example .. code-block:: python message = await client.send_message(chat, 'hello') await client.edit_message(chat, message, 'hello!') # or await client.edit_message(chat, message.id, 'hello!!') # or await client.edit_message(message, 'hello!!!') N)rrrr)r5r]rr\rr)rr5r]rr\rrr)r+rZInputBotInlineMessageIDZInputBotInlineMessageID64rrtrZ_file_to_mediar r-ZEditInlineBotMessageRequestrsessionZdc_idZ_return_exported_senderZ_borrow_exported_senderZ_callr"ZEditMessageRequestrrr)r=r#r]rrrrrrrrrrrZ file_handlerimager/ZexportedZsenderr~rErErF edit_message<sX   zMessageMethods.edit_messagerevokez0typing.Sequence[types.messages.AffectedMessages])r=r# message_idsrrvcst|s|f}dd|D}r>|IdHt}ntjj}|tjjkrt|fddt|DIdHS|fddt|DIdHSdS)a4 Deletes the given messages, optionally "for everyone". See also `Message.delete() `. .. warning:: This method does **not** validate that the message IDs belong to the chat that you passed! It's possible for the method to delete messages from different private chats and small group chats at once, so make sure to pass the right IDs. Arguments entity (`entity`): From who the message will be deleted. This can actually be `None` for normal chats, but **must** be present for channels and megagroups. message_ids (`list` | `int` | `Message `): The IDs (or ID) or messages to be deleted. revoke (`bool`, optional): Whether the message should be deleted for everyone or not. By default it has the opposite behaviour of official clients, and it will delete the message for everyone. `Since 24 March 2019 `_, you can also revoke messages of any age (i.e. messages sent long in the past) the *other* person sent in private conversations (and of course your messages too). Disabling this has no effect on channels or megagroups, since it will unconditionally delete the message for everyone. Returns A list of :tl:`AffectedMessages`, each item being the result for the delete calls of the messages in chunks of 100 each. Example .. code-block:: python await client.delete_messages(chat, messages) css2|]*}t|tjtjtjfr"|jnt|VqdSrm)r+rrZMessageServicerUr5rrrErErFro#s z1MessageMethods.delete_messages..Ncsg|]}tjt|qSrE)r rqDeleteMessagesRequestrgr)r#rErFr1s z2MessageMethods.delete_messages..csg|]}tjt|qSrE)r r-rrgrrrErFr4s ) rrwr"rr0r1r2rpchunks)r=r#rrrBrE)r#rrFdelete_messagess 2     zMessageMethods.delete_messages)rclear_mentionsclear_reactions)r=r#r]rrrrvcs|dkr6|sd}n$t|r0tdd|D}n|j}||IdH}|rp|tj|IdH|dkrp|spdS|r|tj|IdH|dkrdS|dk rt |t j j kr|tj jt||dIdHS|tjj||dIdHSdS)u Marks messages as read and optionally clears mentions. This effectively marks a message as read (or more than one) in the given conversation. If neither message nor maximum ID are provided, all messages will be marked as read by assuming that ``max_id = 0``. If a message or maximum ID is provided, all the messages up to and including such ID will be marked as read (for all messages whose ID ≤ max_id). See also `Message.mark_read() `. Arguments entity (`entity`): The chat where these messages are located. message (`list` | `Message `): Either a list of messages or a single message. max_id (`int`): Until which message should the read acknowledge be sent for. This has priority over the ``message`` parameter. clear_mentions (`bool`): Whether the mention badge should be cleared (so that there are no more mentions) or not for the given entity. If no message is provided, this will be the only action taken. clear_reactions (`bool`): Whether the reactions badge should be cleared (so that there are no more reaction notifications) or not for the given entity. If no message is provided, this will be the only action taken. Example .. code-block:: python # using a Message object await client.send_read_acknowledge(chat, message) # ...or using the int ID of a Message await client.send_read_acknowledge(chat, message_id) # ...or passing a list of messages to mark as read await client.send_read_acknowledge(chat, messages) Nrcss|] }|jVqdSrmr})rJr~rErErFrozsz7MessageMethods.send_read_acknowledge..T)rF)rrwr&r5r"r r-ZReadMentionsRequestZReadReactionsRequestrr0r1rprqZReadHistoryRequestZget_input_channel)r=r#r]rrrrErErFsend_read_acknowledge;s4:  z$MessageMethods.send_read_acknowledge)notify pm_onesidez$typing.Optional[hints.MessageIDLike]r=r#r]rrcs|j||d||dIdHS)a Pins a message in a chat. The default behaviour is to *not* notify members, unlike the official applications. See also `Message.pin() `. Arguments entity (`entity`): The chat where the message should be pinned. message (`int` | `Message `): The message or the message ID to pin. If it's `None`, all messages will be unpinned instead. notify (`bool`, optional): Whether the pin should notify people or not. pm_oneside (`bool`, optional): Whether the message should be pinned for everyone or not. By default it has the opposite behaviour of official clients, and it will pin the message for both sides, in private chats. Example .. code-block:: python # Send and pin a message to annoy everyone message = await client.send_message(chat, 'Pinotifying is fun!') await client.pin_message(chat, message, notify=True) F)unpinrrN_pinrrErErF pin_messages'zMessageMethods.pin_message)rr=r#r]rcs|j||d|dIdHS)a Unpins a message in a chat. If no message ID is specified, all pinned messages will be unpinned. See also `Message.unpin() `. Arguments entity (`entity`): The chat where the message should be pinned. message (`int` | `Message `): The message or the message ID to unpin. If it's `None`, all messages will be unpinned instead. Example .. code-block:: python # Unpin all messages from a chat await client.unpin_message(chat) T)rrNrrrErErF unpin_messageszMessageMethods.unpin_messagecst|p d}||IdH}|dkr@|tj|IdHdStjj||| ||d}||IdH}|sp|jstdS||||S)Nr)rr5rrr) rrr"r r-ZUnpinAllMessagesRequestZUpdatePinnedMessageRequestZupdatesr)r=r#r]rrrr/rDrErErFrs  zMessageMethods._pin)N)r)N)NN)N)N)rarbrcr(rstrboolr4typingUnionOptionalr|inspect signature __signature__rListrZTypeMessageEntityrrrrrrrrrErErErFruTsr  T 3   E  8 P \ , ru)rrPrrrrrrrZ requestiterrtlrr r; TYPE_CHECKINGZtelegramclientr r rerurErErErFs  8