i dZddlZddlZddlmZddlmZmZm Z m Z m Z m Z ddl mZddlmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/m0Z0m1Z1er ddl2m3Z3m4Z4m5Z5e6e7e1eee/e7fe7fZ8ee9dZ:eGdde e/Z;eGddZ<Gddeee/e7fZ=dS)z-This module contains the ConversationHandler.N) dataclass) TYPE_CHECKINGAnyFinalGenericNoReturncast)Update) DEFAULT_TRUE DefaultValue) get_logger)build_repr_with_selected_attrs)DVType)warn)ApplicationHandlerStop)ExtBot) BaseHandler)CallbackQueryHandler)ChosenInlineResultHandler)InlineQueryHandler)StringCommandHandler)StringRegexHandler) TypeHandler) TrackingDict)CCTConversationDictConversationKey) ApplicationJobJobQueueConversationHandler) class_namec@eZdZUdZdZeed<eed<ded<eed<dS) _ConversationTimeoutContextzUsed as a datastore for conversation timeouts. Passed in the :paramref:`JobQueue.run_once.data` parameter. See :meth:`_trigger_timeout`. ) applicationcallback_contextconversation_keyupdater'r(.Application[Any, CCT, Any, Any, Any, JobQueue]r%r&N) __name__ __module__ __qualname____doc__ __slots__r__annotations__r rj/Users/shanyulin/my-agent/.venv/lib/python3.11/site-packages/telegram/ext/_handlers/conversationhandler.pyr$r$3sQRI%%%% NNNAAAAr1r$cNeZdZUdZdZejed<eed<de fdZ defdZ dS) PendingStatea Thin wrapper around :class:`asyncio.Task` to handle block=False handlers. Note that this is a public class of this module, since :meth:`Application.update_persistence` needs to access it. It's still hidden from users, since this module itself is private.  old_statetaskr7r6returnc4|jSN)r7doneselfs r2r;zPendingState.doneMsy~~r1cJ|jstd|j}|r'td|j|jS|j}||j tj}n ||jS|S)aReturns the new state of the :class:`ConversationHandler` if available. If there was an exception during the task execution, then return the old state. If both the new and old state are :obj:`None`, return `CH.END`. If only the new state is :obj:`None`, return the old state. Raises: :exc:`RuntimeError`: If the current task has not yet finished. zNew state is not yet availablez !i   ;4>1%)CC [> ! r1N) r*r+r,r-r.asyncioTaskr/objectboolr;rFr0r1r2r4r4Asw &I , d    r1r4ceZdZUdZdZdZeeed< dZ eeed< dZ eeed< d d d d d d d d e f d d de e eeefdeee e eeeffde e eeefdededededeejzd zded zdedeeefd zdeefdZdefdZede e eeeffdZejdedefdZedeee e eeefffd Zejdedefd!Zede e eeeffd"Zejdedefd#Zedefd$Z e jdedefd%Z edefd&Z!e!jdedefd'Z!edefd(Z"e"jdedefd)Z"edefd*Z#e#jdedefd+Z#edeejzd zfd,Z$e$jdedefd-Z$eded zfd.Z%e%jdedefd/Z%edefd0Z&e&jdedefd1Z&edeeefd zfd2Z'e'jdedefd3Z'd4d5deee(e)efffd6Z*d7ede)fd8Z+d9e,j-d4d:d7ed;edZ/d7ede0ed zfd?Z1d7ed4d@dAe0ed;eded zf dBZ2 dGd9edCe)dDe d zdd fdEZ3d;edd fdFZ4d S)Hr!a# A handler to hold a conversation with a single or multiple users through Telegram updates by managing three collections of other handlers. Warning: :class:`ConversationHandler` heavily relies on incoming updates being processed one by one. When using this handler, :attr:`telegram.ext.ApplicationBuilder.concurrent_updates` should be set to :obj:`False`. Note: :class:`ConversationHandler` will only accept updates that are (subclass-)instances of :class:`telegram.Update`. This is, because depending on the :attr:`per_user` and :attr:`per_chat`, :class:`ConversationHandler` relies on :attr:`telegram.Update.effective_user` and/or :attr:`telegram.Update.effective_chat` in order to determine which conversation an update should belong to. For :attr:`per_message=True `, :class:`ConversationHandler` uses :attr:`update.callback_query.message.message_id ` when :attr:`per_chat=True ` and :attr:`update.callback_query.inline_message_id <.CallbackQuery.inline_message_id>` when :attr:`per_chat=False `. For a more detailed explanation, please see our `FAQ`_. Finally, :class:`ConversationHandler`, does *not* handle (edited) channel posts. .. _`FAQ`: https://github.com/python-telegram-bot/python-telegram-bot/wiki /Frequently-Asked-Questions#what-do-the-per_-settings-in-conversation handler-do The first collection, a :obj:`list` named :attr:`entry_points`, is used to initiate the conversation, for example with a :class:`telegram.ext.CommandHandler` or :class:`telegram.ext.MessageHandler`. The second collection, a :obj:`dict` named :attr:`states`, contains the different conversation steps and one or more associated handlers that should be used if the user sends a message when the conversation with them is currently in that state. Here you can also define a state for :attr:`TIMEOUT` to define the behavior when :attr:`conversation_timeout` is exceeded, and a state for :attr:`WAITING` to define behavior when a new update is received while the previous :attr:`block=False ` handler is not finished. The third collection, a :obj:`list` named :attr:`fallbacks`, is used if the user is currently in a conversation but the state has either no associated handler or the handler that is associated to the state is inappropriate for the update, for example if the update contains a command, but a regular text message is expected. You could use this for a ``/cancel`` command or to let the user know their message was not recognized. To change the state of conversation, the callback function of a handler must return the new state after responding to the user. If it does not return anything (returning :obj:`None` by default), the state will not change. If an entry point callback function returns :obj:`None`, the conversation ends immediately after the execution of this callback function. To end the conversation, the callback function must return :attr:`END` or ``-1``. To handle the conversation timeout, use handler :attr:`TIMEOUT` or ``-2``. Finally, :class:`telegram.ext.ApplicationHandlerStop` can be used in conversations as described in its documentation. Note: In each of the described collections of handlers, a handler may in turn be a :class:`ConversationHandler`. In that case, the child :class:`ConversationHandler` should have the attribute :attr:`map_to_parent` which allows returning to the parent conversation at specified states within the child conversation. Note that the keys in :attr:`map_to_parent` must not appear as keys in :attr:`states` attribute or else the latter will be ignored. You may map :attr:`END` to one of the parents states to continue the parent conversation after the child conversation has ended or even map a state to :attr:`END` to end the *parent* conversation from within the child conversation. For an example on nested :class:`ConversationHandler` s, see :any:`examples.nestedconversationbot`. Examples: * :any:`Conversation Bot ` * :any:`Conversation Bot 2 ` * :any:`Nested Conversation Bot ` * :any:`Persistent Conversation Bot ` Args: entry_points (list[:class:`telegram.ext.BaseHandler`]): A list of :obj:`BaseHandler` objects that can trigger the start of the conversation. The first handler whose :meth:`check_update` method returns :obj:`True` will be used. If all return :obj:`False`, the update is not handled. states (dict[:obj:`object`, list[:class:`telegram.ext.BaseHandler`]]): A :obj:`dict` that defines the different states of conversation a user can be in and one or more associated :obj:`BaseHandler` objects that should be used in that state. The first handler whose :meth:`check_update` method returns :obj:`True` will be used. fallbacks (list[:class:`telegram.ext.BaseHandler`]): A list of handlers that might be used if the user is in a conversation, but every handler for their current state returned :obj:`False` on :meth:`check_update`. The first handler which :meth:`check_update` method returns :obj:`True` will be used. If all return :obj:`False`, the update is not handled. allow_reentry (:obj:`bool`, optional): If set to :obj:`True`, a user that is currently in a conversation can restart the conversation by triggering one of the entry points. Default is :obj:`False`. per_chat (:obj:`bool`, optional): If the conversation key should contain the Chat's ID. Default is :obj:`True`. per_user (:obj:`bool`, optional): If the conversation key should contain the User's ID. Default is :obj:`True`. per_message (:obj:`bool`, optional): If the conversation key should contain the Message's ID. Default is :obj:`False`. conversation_timeout (:obj:`float` | :obj:`datetime.timedelta`, optional): When this handler is inactive more than this timeout (in seconds), it will be automatically ended. If this value is ``0`` or :obj:`None` (default), there will be no timeout. The last received update and the corresponding :class:`context <.CallbackContext>` will be handled by *ALL* the handler's whose :meth:`check_update` method returns :obj:`True` that are in the state :attr:`ConversationHandler.TIMEOUT`. Caution: * This feature relies on the :attr:`telegram.ext.Application.job_queue` being set and hence requires that the dependencies that :class:`telegram.ext.JobQueue` relies on are installed. * Using :paramref:`conversation_timeout` with nested conversations is currently not supported. You can still try to use it, but it will likely behave differently from what you expect. name (:obj:`str`, optional): The name for this conversation handler. Required for persistence. persistent (:obj:`bool`, optional): If the conversation's dict for this handler should be saved. :paramref:`name` is required and persistence has to be set in :attr:`Application <.Application.persistence>`. .. versionchanged:: 20.0 Was previously named as ``persistence``. map_to_parent (dict[:obj:`object`, :obj:`object`], optional): A :obj:`dict` that can be used to instruct a child conversation handler to transition into a mapped state on its parent conversation handler in place of a specified nested state. block (:obj:`bool`, optional): Pass :obj:`False` or :obj:`True` to set a default value for the :attr:`BaseHandler.block` setting of all handlers (in :attr:`entry_points`, :attr:`states` and :attr:`fallbacks`). The resolution order for checking if a handler should be run non-blocking is: 1. :attr:`telegram.ext.BaseHandler.block` (if set) 2. the value passed to this parameter (if any) 3. :attr:`telegram.ext.Defaults.block` (if defaults are used) .. seealso:: :wiki:`Concurrency` .. versionchanged:: 20.0 No longer overrides the handlers settings. Resolution order was changed. Raises: :exc:`ValueError`: If :paramref:`persistent` is used but :paramref:`name` was not set, or when :attr:`per_message`, :attr:`per_chat`, :attr:`per_user` are all :obj:`False`. Attributes: block (:obj:`bool`): Determines whether the callback will run in a blocking way. Always :obj:`True` since conversation handlers handle any non-blocking callbacks internally. )_allow_reentry_block_child_conversations_conversation_timeout_conversations _entry_points _fallbacks_map_to_parent_name _per_chat _per_message _per_user _persistent_states_timeout_jobs_lock timeout_jobsrCTIMEOUTWAITINGFTNr=zConversationHandler[CCT] entry_pointsstates fallbacks allow_reentryper_chatper_user per_messageconversation_timeoutname persistent map_to_parentblockc 6ddlm} m}m}m}d|_| |_||_||_||_ ||_ ||_ ||_ ||_ ||_| |_| |_i|_t%j|_i|_t-|_| r|jst3d| |_t7|j|j|jfst3d|jr|jst?ddg}| || ||!D]}| ||j"d |Dd }|D]}tG|tHtJzr!t?d |j&j'd dn!tG|tPr:tS|j*tVs t?d |j*j'ddntG||rt?ddn|jrHtG||tXztZz|z| zr"t?d|j&j'd|dna|jr*tG|t\st?d|dn0|js)tG|t\rt?d|d|j/r&tG||j&rt?dddS)Nr)PollAnswerHandler PollHandlerPreCheckoutQueryHandlerShippingQueryHandlerTz:Conversations can't be persistent when handler is unnamed.z='per_user', 'per_chat' and 'per_message' can't all be 'False'znIf 'per_message=True' is used, 'per_chat=True' should also be used, since message IDs are not globally unique. stacklevelc3DK|]}t|t|VdSr:) isinstancer!).0handlers r2 z/ConversationHandler.__init__..csF) ) :gGZ3[3[) ) ) ) ) ) ) r1z Read this FAQ entry to learn more about the per_* settings: https://github.com/python-telegram-bot/python-telegram-bot/wiki/Frequently-Asked-Questions#what-do-the-per_-settings-in-conversationhandler-do.zJThe `ConversationHandler` only handles updates of type `telegram.Update`. z handles updates of type `str`.zkThe `ConversationHandler` only handles updates of type `telegram.Update`. The TypeHandler is set to handle .zPollHandler will never trigger in a conversation since it has no information about the chat or the user who voted in it. Do you mean the `PollAnswerHandler`?zUpdates handled by zb only have information about the user, so this handler won't ever be triggered if `per_chat=True`.zIf 'per_message=True', all entry points, state handlers, and fallbacks must be 'CallbackQueryHandler', since no other handlers have a message context.zUIf 'per_message=False', 'CallbackQueryHandler' will not be tracked for every message.zUsing `conversation_timeout` with nested conversations is currently not supported. You can still try to use it, but it will likely behave differently from what you expect.)0 telegram.extrnrorprqrlrMrQrYrRrLrWrUrVrOrTrSr[rGLockrZrPsetrNri ValueErrorrXanyrfrergrextendvaluesr(rvrr __class__r*r issubclasstyper rrrrh)r=rarbrcrdrerfrgrhrirjrkrlrnrorprq all_handlersstate_handlers per_faq_linkrxs r2__init__zConversationHandler.__init__sy             $( $) EQMS BK$1''"-CW"!% ;H>@"),..02>Aee!  [di [YZZ Z!+DM4=$2BCDD ^\]] ]   DM  =     @B L)))I&&&$mmoo 0 0N    / / / / !(() ) #/) ) )     _ $: : G'#7:L#LMM1 S(1SSS  G[11+ *W\SY:Z:Z+ R9@9NRRR  G[11% + !  (()/0..( ( &'*;*D&&#&& ! ! *W>R*S*S =.:== !  % *W>R*S*S @1=@@  ( Z-P-P 8 ! k: : r1r8cd}tt|jd|}t |}t |j|kr |dddz}t ||j|S)aGive a string representation of the ConversationHandler in the form ``ConversationHandler[name=..., states={...}]``. If there are more than 3 states, only the first 3 states are listed. As this class doesn't implement :meth:`object.__str__`, the default implementation will be used, which is equivalent to :meth:`__repr__`. Returns: :obj:`str` Nr\z, ...})rirb)dictlistrbitemsstrlenrri)r=truncation_thresholdrb states_strings r2__repr__zConversationHandler.__repr__s !d4;,,..//0E1E0EFGGF t{  2 2 2)#2#.9M-      r1c|jS)zlist[:class:`telegram.ext.BaseHandler`]: A list of :obj:`BaseHandler` objects that can trigger the start of the conversation. )rQr<s r2raz ConversationHandler.entry_pointss !!r1_c td)NzDYou can not assign a new value to entry_points after initialization.AttributeErrorr=rs r2raz ConversationHandler.entry_pointss R   r1c|jS)adict[:obj:`object`, list[:class:`telegram.ext.BaseHandler`]]: A :obj:`dict` that defines the different states of conversation a user can be in and one or more associated :obj:`BaseHandler` objects that should be used in that state. )rYr<s r2rbzConversationHandler.statess |r1c td)Nz>You can not assign a new value to states after initialization.rrs r2rbzConversationHandler.statess]^^^r1c|jS)zlist[:class:`telegram.ext.BaseHandler`]: A list of handlers that might be used if the user is in a conversation, but every handler for their current state returned :obj:`False` on :meth:`check_update`. )rRr<s r2rczConversationHandler.fallbackss r1c td)NzAYou can not assign a new value to fallbacks after initialization.rrs r2rczConversationHandler.fallbackss`aaar1c|jS)zQ:obj:`bool`: Determines if a user can restart a conversation with an entry point.)rLr<s r2rdz!ConversationHandler.allow_reentrys ""r1c td)NzEYou can not assign a new value to allow_reentry after initialization.rrs r2rdz!ConversationHandler.allow_reentry S   r1c|jS)zB:obj:`bool`: If the conversation key should contain the User's ID.)rWr<s r2rfzConversationHandler.per_user ~r1c td)Nz@You can not assign a new value to per_user after initialization.rrs r2rfzConversationHandler.per_user_```r1c|jS)zB:obj:`bool`: If the conversation key should contain the Chat's ID.)rUr<s r2rezConversationHandler.per_chatrr1c td)Nz@You can not assign a new value to per_chat after initialization.rrs r2rezConversationHandler.per_chatrr1c|jS)zE:obj:`bool`: If the conversation key should contain the message's ID.)rVr<s r2rgzConversationHandler.per_messages   r1c td)NzCYou can not assign a new value to per_message after initialization.rrs r2rgzConversationHandler.per_message sbcccr1c|jS)z:obj:`float` | :obj:`datetime.timedelta`: Optional. When this handler is inactive more than this timeout (in seconds), it will be automatically ended. )rOr<s r2rhz(ConversationHandler.conversation_timeouts ))r1c td)NzLYou can not assign a new value to conversation_timeout after initialization.rrs r2rhz(ConversationHandler.conversation_timeouts Z   r1c|jS)zE:obj:`str`: Optional. The name for this :class:`ConversationHandler`.)rTr<s r2rizConversationHandler.names zr1c td)Nz`. )rXr<s r2rjzConversationHandler.persistent(s r1c td)NzBYou can not assign a new value to persistent after initialization.rrs r2rjzConversationHandler.persistent0sabbbr1c|jS)a dict[:obj:`object`, :obj:`object`]: Optional. A :obj:`dict` that can be used to instruct a nested :class:`ConversationHandler` to transition into a mapped state on its parent :class:`ConversationHandler` in place of a specified nested state. )rSr<s r2rkz!ConversationHandler.map_to_parent4s ""r1c td)NzEYou can not assign a new value to map_to_parent after initialization.rrs r2rkz!ConversationHandler.map_to_parent<rr1r%rcdK|jr|jr|jstd|j}t dt |_|j||j|jd{V}|j || D],\}}||j kr| |j |-|j|ji}|j D]1}|||d{V2|S)aInitializes the persistence for this handler and its child conversations. While this method is marked as protected, we expect it to be called by the Application/parent conversations. It's just protected to hide it from users. Args: application (:class:`telegram.ext.Application`): The application. Returns: A dict {conversation.name -> TrackingDict}, which contains all dict of this conversation and possible child conversations. zRThis handler is not persistent, has no name or the application has no persistence!z%TrackingDict[ConversationKey, object]N) new_statekey)r%)rjri persistencer?rPr rr(get_conversationsupdate_no_trackrrC _update_staterN_initialize_persistence)r=r%current_conversations stored_datarstateoutrxs r2rz+ConversationHandler._initialize_persistenceBs DI +2I   !% 3" 3 NN   ""#8999(3EEdiPPPPPPPP  ++K888 &++-- @ @JC  ""TX3"???y$-.0  G JJ55 +6      r1r(c|j}|j}g}|jr+|td||j|jr+|td||j|jrf|jtd|jj r ||jj n$||jj j t|S)z7Builds the conversation key associated with the update.Nz2Can't build key for update without effective chat!z2Can't build key for update without effective user!z1Can't build key for update without CallbackQuery!) effective_chateffective_userrer?appendidrfrgcallback_queryinline_message_idmessage message_idtuple)r=r(chatuserrs r2_get_keyzConversationHandler._get_keyvs$$! = |"#WXXX JJtw    = |"#WXXX JJtw      E$,"#VWWW$6 E 60BCCCC 608CDDDSzzr1rr)contextr'cK |d{V}n4#t$r'}td|Yd}~dSd}~wwxYw||||||S)NzTNon-blocking handler callback raised exception. Not scheduling conversation timeout.exc_info)rr%r(rr') ExceptionrAdebug _schedule_job)r=rr%r(rr'effective_new_staterDs r2_schedule_job_delayedz)ConversationHandler._schedule_job_delayeds (1//////      MM     44444  !!)#- "   s >9>c  ||jkrdS |j}||j|jt |||||j|<dS#t$r'}t d|Yd}~dSd}~wwxYw)zRSchedules a job which executes :meth:`_trigger_timeout` upon conversation timeout.N)datazFailed to schedule timeout.r) rC job_queuerun_once_trigger_timeoutrhr$r[rrAr@)r=rr%r(rr'j_queuerDs r2rz!ConversationHandler._schedule_jobs  F K!+G292B2B%)01A6;X_``3C33D . / / /  K K K   ;c  J J J J J J J J J KsAA BA>>Bc6t|tsdS|js|jrdS|jr |jsdS|jr |jsdS|jr |j sdS|j r|jr|j j sdS| |}|j |}d}t|trtd|r|}|j7|jr|j |dd}n||||j |}nO|j |jg}|D]*}||}||dur |j|||fcS+dStdt7|t7|d}||jr-|jD]!} | |}||dur| }n"|dS|j|h|j |gD]!} | |}||dur| }n,"|jD]!} | |}||dur| }n"dS||||fS)a( Determines whether an update should be handled by this conversation handler, and if so in which state the conversation currently is. Args: update (:class:`telegram.Update` | :obj:`object`): Incoming update. Returns: :obj:`bool` Nz&Waiting for asyncio Task to finish ...Fz'Selecting conversation %s with state %s)rvr channel_postedited_channel_postrerrfrrgrrrrPgetr4rArr;rFr6r7r@poprrbr` check_updaterrdrarc) r=r(rrcheckrEhandlershandler_rx entry_point candidatefallbacks r2rz ConversationHandler.check_updates&&)) 4   &"< 4 = !6 4 = !6 4   F$9 4   T] 6;P;X 4mmF###'',,# e\ * *  MMB C C Czz|| mmoo?*uz/C/C/E/E*'++C666 EE&&sC000 /33C88EE ;??4<<< (BBH$11&99E(U%-?-?#|S(EAAAAt ?S3u::VVV&* =D.=#0  #0088$e););)GE=4  ![__UB77  !..v66$e););'GE!%  H$11&99E(U%-?-?"* 4c7E))r1z)Application[Any, CCT, Any, Any, Any, Any] check_resultc K|\}}}}d} |j4d{V|j|d} | | dddd{Vn#1d{VswxYwY|jt ur|j} ng|jt ur|j} nQt|jtr|jj |jj j} ntj |j} | r| ||||d{V} n7|| |||||d|jd} n #t $r} | j} d} Yd} ~ nd} ~ wwxYw|j4d{V|jr|jt)dd n|jjjst)d d nlt| t.jr9||| |||||d|jd  n|| ||||dddd{Vn#1d{VswxYwYt|jt8rh| |jvr_||j||| r't!|j| |j| S||j kr|| ||| rt dS) aLSend the update to the callback for the current state and BaseHandler Args: check_result: The result from :meth:`check_update`. For this handler it's a tuple of the conversation state, key, handler, and the handler's check result. update (:class:`telegram.Update`): Incoming telegram update. application (:class:`telegram.ext.Application`): Application that originated the update. context (:class:`telegram.ext.CallbackContext`): The context as provided by the application. FNzConversationHandler:z:handle_update:non_blocking_cb) coroutiner(riTzHIgnoring `conversation_timeout` because the Application has no JobQueue.rszQIgnoring `conversation_timeout` because the Applications JobQueue is not running.z:handle_update:timeout_job)r(ri)!rZr[rschedule_removalrlr rMrvbotrdefaultsr get_value handle_update create_task update_idrrrhrr schedulerrunningrGrHrrrkrrrCrr`)r=r(r%rr current_stater'rxhandler_check_resultraise_dp_handler_stop timeout_jobrlrr@s r2rz!ConversationHandler.handle_updates&JVF '2F %* / / / / / / / /+//0@$GGK&,,...  / / / / / / / / / / / / / / / / / / / / / / / / / / / = , ,MEE [ , ,KEE   0 0 :[_5M5YO,2EE *7=99E ) *1*?*?K)=w++%%%%%% (33%33 -A7"`0@``` 4 & ) ) )!I$( ! ! ! ! ! ! )* b b b b b b b b( b(0b#$%.8@b'#$  7<88 b ++22%{FGEU &`F4D``` ,&&y+vwP`aaa1 b b b b b b b b b b b b b b b b b b b b b b b b b b b4 d($ / / 5IAS4S4S   tx)97 C C C$ P,T-?-C-CI-N-NOOO%)))44 4 DL ( (   y*:G D D D  )) (ts=2A A'*A',AE E" EE"2B0H44 H>H>rrxc||jkr||jvr |j|=dSdSt|tjr3t |j|||j|<dS|[||jvrFt|t|j j ndd|d|j d|j znddd ||j|<dSdS) Nr5rz returned state z, which is unknown to the ConversationHandler rzrrrs) rCrPrvrGrHr4rrbrreprcallbackr*ri)r=rrrxs r2rz!ConversationHandler._update_states2  d)))',,,*) 7< 0 0 1'3-11#66Y(((D  $ $ $ " ++:A:MtG,5666S`^^&/^^=AY=R# //XZ^^^ !  (1D  $ $ $# "r1cKtd|j}td|j}td|j|j}|j4d{V|j |j}||ur dddd{VdS|j|j=dddd{Vn#1d{VswxYwY|j |j g}|D]m}| |j }|O|durK ||j |j||d{VL#t $rt#ddYiwxYwn||j|jdS) zThis is run whenever a conversation has timed out. Also makes sure that all handlers which are in the :attr:`TIMEOUT` state and whose :meth:`BaseHandler.check_update` returns :obj:`True` is handled. rr$z7Conversation timeout was triggered for conversation %s!NFzWApplicationHandlerStop in TIMEOUT state of ConversationHandler has no effect. Ignoring.rrrs)r jobrrArr'r&rZr[rrbr^rr(rr%rrrrC) r=rrctxtr& found_jobrrxrs r2rz$ConversationHandler._trigger_timeouts 5'+&&138<< EtG\    0* 9 9 9 9 9 9 9 9)--d.CDDI##  9 9 9 9 9 9 9 9 9 9 9 9 9 9 !$"78  9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9;??4<44  G((55E U%%7%7 !// T%5u>N.G#$ 48T%:;;;;;s*!%B8 B88 CC(D77EEr:)5r*r+r,r-r.rCrintr/r^r`r rrr rrIrrJfloatdtm timedeltarrrrpropertyrasetterrrbrcrdrfrergrhrirjrkrrrrrGrHrr_CheckUpdateTyperrrrr0r1r2r!r!nsOObI&CsPGU3ZGU3Z?$!=A 59*LL(L;vsF':;<LVT+fc6.A"BCCDL FC$789 L  L  LLL$cm3d:LDjLLFFN+d2Ld|LLLL\ #    0"d;vsF/B#CD"""X"  f     VT+fc66I*J%KKLX ]__8___]_4 FC,? @AXb6bhbbbb#t###X# v (    $X_a&aXaaa_a$X_a&aXaaa_a!T!!!X!dVddddd*   %***X*  f    !  cDjX []f]]]][] D   X cFcxcccc#tFFN3d:###X# v (    2(2 c< 788 92222hv/6 < F     *       2KKFK K  K * K KKKK0Y*6Y*.>s.Cd.JY*Y*Y*Y*vbbAb's+ b  b $ bbbbJVZ111&51@Kd@R1 1111.%r-rGdatetimer dataclassesrtypingrrrrrr telegramr telegram._utils.defaultvaluer r telegram._utils.loggingr telegram._utils.reprrtelegram._utils.typesrtelegram._utils.warningsrtelegram.ext._applicationrtelegram.ext._extbotr"telegram.ext._handlers.basehandlerr+telegram.ext._handlers.callbackqueryhandlerr0telegram.ext._handlers.choseninlineresulthandlerr)telegram.ext._handlers.inlinequeryhandlerr+telegram.ext._handlers.stringcommandhandlerr)telegram.ext._handlers.stringregexhandlerr"telegram.ext._handlers.typehandlerr telegram.ext._utils.trackingdictrtelegram.ext._utils.typesrrrr{rrr rrIrr*rAr$r4r!r0r1r2rs&43!!!!!!EEEEEEEEEEEEEEEECCCCCCCC......??????(((((())))))<<<<<<''''''::::::LLLLLLVVVVVVHHHHHHLLLLLLHHHHHH::::::999999LLLLLLLLLL87777777777+fc6>Q2RTZZ[ *X*? @ @ @      '#,     ))))))) )XO <O <O <O <O <+fc6&9:O <O <O <O <O