U hK@shddlZddlZddlZddlZddlZddlmZddlmZm Z m Z dZ ddZ Gd d d eZ dS) N) ChatGetter)helpersutilserrorsgMbP?cstfdd}|S)Ncs |jrtd|f||S)Nz%The conversation was cancelled before) _cancelledasyncioZCancelledError)selfargskwargsfC/tmp/pip-unpacked-wheel-c81u5j2r/telethon/tl/custom/conversation.pywrappers z"_checks_cancelled..wrapper) functoolswraps)rrrr r_checks_cancelledsrc@seZdZdZdZdZddZeddZeddZ ed/d d Z d0d d d dZ d1d d ddZ ddZ d2d d ddZd3d d ddZd d ddZddZddZddZdd Zd!d"Zed#d$Zd4d%d&Zd'd(Zd)d*Zd+d,Zd-d.ZejZejZ d S)5 ConversationaT Represents a conversation inside an specific chat. A conversation keeps track of new messages since it was created until its exit and easily lets you query the current state. If you need a conversation across two or more chats, you should use two conversations and synchronize them as you better see fit. rcCstj||dtj|_tjd7_||_||_||_d|_t |_ d|_ g|_ d|_ ||_d|_i|_i|_i|_i|_i|_||_d|_i|_|r|j|_ni|_i|_dS)N) input_chatrrF)r__init__r _id_counterZ_id_client_timeout_total_timeout _total_dueset _outgoing_last_outgoing _incoming_last_incoming _max_incoming _last_read_custom_pending_responses_pending_replies_pending_edits_pending_reads _exclusiver_response_indices_reply_indices _edit_dates)r clientrtimeoutZ total_timeoutZ max_messagesZ exclusiveZreplies_are_responsesrrrr)s2 zConversation.__init__csV|jj|jf||IdH}t|tr*|n|f}|jdd|D|dj|_|S)z Sends a message in the context of this conversation. Shorthand for `telethon.client.messages.MessageMethods.send_message` with ``entity`` already set. Ncss|] }|jVqdSNid.0mrrr ]sz,Conversation.send_message..) r send_message _input_chat isinstancelistrupdater1rr r r sentmsrrrr7Qs  zConversation.send_messagecsV|jj|jf||IdH}t|tr*|n|f}|jdd|D|dj|_|S)z Sends a file in the context of this conversation. Shorthand for `telethon.client.uploads.UploadMethods.send_file` with ``entity`` already set. Ncss|] }|jVqdSr/r0r2rrrr5msz)Conversation.send_file..r6) r send_filer8r9r:rr;r1rr<rrrr?as  zConversation.send_fileNcCsD|dkr"|jr|jdj}q2d}nt|ts2|j}|jj|j|dS)a, Marks as read the latest received message if ``message is None``. Otherwise, marks as read until the given message (or message ID). This is equivalent to calling `client.send_read_acknowledge `. Nr6r)max_id)r r1r9intrZsend_read_acknowledger8r messagerrr mark_readqs  zConversation.mark_readr.cCs|||j|j|ddS)a Gets the next message that responds to a previous one. This is the method you need most of the time, along with `get_edit`. Args: message (`Message ` | `int`, optional): The message (or the message ID) for which a response is expected. By default this is the last sent message. timeout (`int` | `float`, optional): If present, this `timeout` (in seconds) will override the per-action timeout defined for the conversation. .. code-block:: python async with client.conversation(...) as conv: await conv.send_message('Hey, what is your name?') response = await conv.get_response() name = response.text await conv.send_message('Nice to meet you, {}!'.format(name)) cSsdSNTrxyrrrz+Conversation.get_response..) _get_messager*r%r rCr.rrr get_responseszConversation.get_responsecCs|||j|j|ddS)zR Gets the next message that explicitly replies to a previous one. cSs|jo|jj|kSr/)reply_toreply_to_msg_idrGrrrrJrKz(Conversation.get_reply..)rLr+r&rMrrr get_replyszConversation.get_replyc Cst}||}||krRt|jD]\}} | j|kr$|||<qRq$t|j||<|jj} ||} | t|jkr|j| } || |r||d7<| | | S| ||<| | ||||S)a Gets the next desired message under the desired condition. Args: target_message (`object`): The target message for which we want to find another response that applies based on `condition`. indices (`dict`): This dictionary remembers the last ID chosen for the input `target_message`. pending (`dict`): This dictionary remembers {msg_id: Future} to be set once `condition` is met. timeout (`int`): The timeout (in seconds) override to use for this operation. condition (`callable`): The condition callable that checks if an incoming message is a valid response. r) time_get_message_id enumerater r1lenrloop create_future set_result _get_result) r Ztarget_messageindicespendingr. condition start_time target_idiincomingfutureZlast_idxrrrrLs$      zConversation._get_messagecst}|||jdtfdd|jDdddd}|jj}|r|j kr|j |j<| ||S||j <| ||||j S)z Awaits for an edit after the last message to arrive. The arguments are the same as those for `get_response`. rc3s0|](}|jr|jkr|jkr|VqdSr/) edit_dater1 timestamp)r3rHZ target_dater^rrr5s  z(Conversation.get_edit..cSs |jSr/)rbrc)rHrrrrJrKz'Conversation.get_edit..N)keydefault)rRrSr,getminr rrVrWrbrcrXr'rY)r rCr.r]Z earliest_editrarrdrget_edits    zConversation.get_editcCs^t}|jj}||}|jdkr2|d|_|j|kr@dS||j|<|||||j|S)z Awaits for the sent message to be marked as read. Note that receiving a response doesn't imply the message was read, and this action will also trigger even without a response. Nr)rRrrVrWrSr#r(rY)r rCr.r]rar^rrr wait_reads      zConversation.wait_readc st}t|tr|}||jIdHtj}tjd7_|jj}||f|j |<z| ||||j |IdHWS|j |dXdS)a$ Waits for a custom event to occur. Timeouts still apply. .. note:: **Only use this if there isn't another method available!** For example, don't use `wait_event` for new messages, since `get_response` already exists, etc. Unless you're certain that your code will run fast enough, generally you should get a "handle" of this special coroutine before acting. In this example you will see how to wait for a user to join a group with proper use of `wait_event`: .. code-block:: python from telethon import TelegramClient, events client = TelegramClient(...) group_id = ... async def main(): # Could also get the user id from an event; this is just an example user_id = ... async with client.conversation(user_id) as conv: # Get a handle to the future event we'll wait for handle = conv.wait_event(events.ChatAction( group_id, func=lambda e: e.user_joined and e.user_id == user_id )) # Perform whatever action in between await conv.send_message('Please join this group before speaking to me!') # Wait for the event we registered above to fire event = await handle # Continue with the conversation await conv.send_message('Thanks!') This way your event can be registered before acting, since the response may arrive before your event was registered. It depends on your use case since this also means the event can arrive before you send a previous action. Nr) rRr9typeresolverr_custom_counterrVrWr$poprY)r eventr.r]counterrarrr wait_events0  zConversation.wait_eventcsht|jD]T\}\}}t|}||}|r||}t|rL|IdH}|r|||j|=qdSr/)r:r$itemsrkfilterinspect isawaitablerX)r ZbuiltreZevfutZev_typeinstrsrrr _check_customZs    zConversation._check_customcCs|j}|j|jks|jrdSt|j|jkr>|tddS|j|t |j D]*\}}t|j|j |<| ||j |=qXt |j D]<\}}|jr||jjkrt|j|j|<| ||j|=qdS)NzToo many incoming messages)rCchat_idoutrUr r" _cancel_all ValueErrorappendr:r%rrr*rXr&rOrPr+)r responsemsg_idrarrr_on_new_messagehs     zConversation._on_new_messagecCs|j}|j|jks|jrdSt|jD]"\}}|j|jkr&||j|<qJq&t|jD]d\}}||jkrX|j }||j |dkr|j |t 7<n|j |j |<|||j|=qXdS)Nr)rCryrzrTr r1r:r'rrrbrcr,rg_EDIT_COLLISION_DELTArX)r rCr_r4rraZedit_tsrrr_on_edits     zConversation._on_editcCsV|j|jks|jrdS|j|_t|jD]$\}}||jkr,|d|j|=q,dSrF)ryZinboxr@r#r:r(rrrX)r rorr[rrr_on_reads  zConversation._on_readcCs4|dk rt|tr|S|jS|jr(|jStddS)NzNo message was sent previously)r9rAr1rr|rBrrrrSs zConversation._get_message_idcCsP|j}|dkr|j}|dk r*t|||}tj||tdkr@dn |tdS)NinfrE)rrrhr wait_forfloatrR)r rar]r.r[r^ZduerrrrYszConversation._get_resultcCstd|_t|j|j|jD]}|r:||q&|q&|j D] \}}|rf||qN|qNdSrF) r itertoolschainr%valuesr&r'Z set_exceptioncancelr$)r exceptionr[_rvrrrr{s   zConversation._cancel_allc s|j|jIdH|_t|j|_t|j}|jj|}|jrN|rNt | |d|_ d|_ d|_|j|j|j|j|j|j|j|j|jf D] }|q|jrt|j|_n td|_|S)NFrr)rZget_input_entityr8rZget_peer _chat_peer get_peer_id_conversationsr)rZAlreadyInConversationErroraddrrr!rr r%r&r'r*r+r,r$clearrrRrr)r ryconv_setdrrr __aenter__s4      zConversation.__aenter__cCs |dS)z Cancels the current conversation. Pending responses and subsequent calls to get a response will raise ``asyncio.CancelledError``. This method is synchronous and should not be awaited. N)r{)r rrrrszConversation.cancelcs2|j|jIdH}|jj|D] }|q dS)z Calls `cancel` on *all* conversations in this chat. Note that you should ``await`` this method, since it's meant to be used outside of a context manager, and it needs to resolve the chat. N)rrr8rr)r ryconvrrr cancel_allszConversation.cancel_allcs<t|j}|jj|}|||s0|jj|=|dSr/)rrrrrdiscardr{)r exc_typeexc_valexc_tbryrrrr __aexit__s     zConversation.__aexit__)N)N)N)N)N)N)!__name__ __module__ __qualname____doc__rrmrrr7r?rDrNrQrLrirjrqrxrrrrSrYr{rrrrrZ _sync_enter __enter__Z _sync_exit__exit__rrrrrs< (    =B      r)r rrtrrRZ chatgetterrrrrrrrrrrrs