o /h@sdZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZmZmZmZddlmZddlmZmZddlmZddlmZdd lmZdd lmZdd lm Z dd l!m"Z"dd l#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4m5Z5m6Z6erddl7m8Z8m9Z9m:Z:ee;e6e$ee4e;fe;fZeGddde e4Z?eGdddZ@Gddde$ee4e;fZAdS)z-This module contains the ConversationHandler.N) dataclass) TYPE_CHECKINGAnyDictFinalGenericListNoReturnOptionalSetTupleUnioncast)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@s6eZdZUdZdZeed<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__rr r4r4c/var/www/html/govbot/env/lib/python3.10/site-packages/telegram/ext/_handlers/conversationhandler.pyr(?s  r(c@sDeZdZUdZdZejed<eed<de fddZ defdd Z d S) 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_statetaskr9r8returncCs |jSN)r9doneselfr4r4r5r<Ys zPendingState.donecCsl|js td|j}|rtd|j|jS|j}|dur-|jdur-tj}|S|dur4|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 availablezexcresr4r4r5resolve\s   zPendingState.resolveN) r.r/r0r1r2asyncioTaskr3objectboolr<rFr4r4r4r5r6Ms  r6c@s eZdZUdZdZdZeeed< dZ eeed< dZ eeed< d d d d d d d d e f d d de e eeefdeee e eeeffde e eeefdededededeeeejfdeededeeeefdeefddZdefddZede e eeeffdd Zejd!edefd"d Zedeee e eeefffd#d$Z e jd!edefd%d$Z ede e eeeffd&d'Z!e!jd!edefd(d'Z!edefd)d*Z"e"jd!edefd+d*Z"edefd,d-Z#e#jd!edefd.d-Z#edefd/d0Z$e$jd!edefd1d0Z$edefd2d3Z%e%jd!edefd4d3Z%edeeeejffd5d6Z&e&jd!edefd7d6Z&edeefd8d9Z'e'jd!edefd:d9Z'edefd;d<Z(e(jd!edefd=d<Z(edeeeeffd>d?Z)e)jd!edefd@d?Z)dAdBdeee*e+efffdCdDZ,dEede+fdFdGZ-dHe.j/dAdIdEedJedKe+dd f dLdMZ0dHedAdIdEedJedKe+dd f dNdOZ1dEedee2efdPdQZ3dEedAdRdSe2edJedeef dTdUZ4 d\dHedVe+dWee dd fdXdYZ5dJedd fdZd[Z6d S)]r&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 Cs6ddlm} m}m}m}d|_| |_||_||_||_ ||_ ||_ ||_ ||_ ||_| |_| |_i|_t|_i|_t|_| rH|jsHtd| |_t|j|j|jfsYtd|jre|jsetdddg}| || ||!D]}| |qu|j"d d |Dd }|D]}t#|t$t%frtd |j&j'd ddnet#|t(rt)|j*t+std|j*j'dddnMt#||rtdddnA|jrt#||t,t-|| frtd|j&j'd|ddn%|jrt#|t.std|ddn|jst#|t.rtd|dd|j/rt#||j&rtdddqdS)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. stacklevelcss|] }t|tr|VqdSr;) isinstancer&).0handlerr4r4r5 qs   z/ConversationHandler.__init__..z 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.extrlrmrnrorkrLrPrXrQrKrVrTrUrNrSrRrZrGLockrYrOsetrMrh ValueErrorrWanyrerdrfrextendvaluesr,rsrr __class__r.r issubclasstyperrrrrg)r>r`rarbrcrdrerfrgrhrirjrkrlrmrnro all_handlersstate_handlers per_faq_linkrur4r4r5__init__*s           zConversationHandler.__init__r:cCsTd}tt|jd|}t|}t|j|kr"|ddd}t||j|dS)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, ...})rhra)dictlistraitemsstrlenrrh)r>truncation_thresholdra states_stringr4r4r5__repr__s zConversationHandler.__repr__cC|jS)zList[:class:`telegram.ext.BaseHandler`]: A list of :obj:`BaseHandler` objects that can trigger the start of the conversation. )rPr=r4r4r5r`sz ConversationHandler.entry_points_cCtd)NzDYou can not assign a new value to entry_points after initialization.AttributeErrorr>rr4r4r5r`cCr)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. )rXr=r4r4r5razConversationHandler.statescCr)Nz>You can not assign a new value to states after initialization.rrr4r4r5racCr)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`. )rQr=r4r4r5rbrzConversationHandler.fallbackscCr)NzAYou can not assign a new value to fallbacks after initialization.rrr4r4r5rbrcCr)zQ:obj:`bool`: Determines if a user can restart a conversation with an entry point.)rKr=r4r4r5rcz!ConversationHandler.allow_reentrycCr)NzEYou can not assign a new value to allow_reentry after initialization.rrr4r4r5rcrcCr)zB:obj:`bool`: If the conversation key should contain the User's ID.)rVr=r4r4r5rerzConversationHandler.per_usercCr)Nz@You can not assign a new value to per_user after initialization.rrr4r4r5re rcCr)zB:obj:`bool`: If the conversation key should contain the Chat's ID.)rTr=r4r4r5rd rzConversationHandler.per_chatcCr)Nz@You can not assign a new value to per_chat after initialization.rrr4r4r5rdrcCr)zE:obj:`bool`: If the conversation key should contain the message's ID.)rUr=r4r4r5rfrzConversationHandler.per_messagecCr)NzCYou can not assign a new value to per_message after initialization.rrr4r4r5rfrcCr)z:obj:`float` | :obj:`datetime.timedelta`: Optional. When this handler is inactive more than this timeout (in seconds), it will be automatically ended. )rNr=r4r4r5rgsz(ConversationHandler.conversation_timeoutcCr)NzLYou can not assign a new value to conversation_timeout after initialization.rrr4r4r5rg)rcCr)zE:obj:`str`: Optional. The name for this :class:`ConversationHandler`.)rSr=r4r4r5rh/rzConversationHandler.namecCr)Nz`. )rWr=r4r4r5ri8rzConversationHandler.persistentcCr)NzBYou can not assign a new value to persistent after initialization.rrr4r4r5ri@rcCr)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. )rRr=r4r4r5rjDrz!ConversationHandler.map_to_parentcCr)NzEYou can not assign a new value to map_to_parent after initialization.rrr4r4r5rjLrr)r#cs|jr |jr |jstd|j}ttttft|_|j ||j |jIdH}|j || D]\}}||j krG|j|j |dq6|j|ji}|jD]}| |j|dIdHqQ|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!N) new_statekey)r))rirh persistencer?rOrrr"rIr,get_conversationsupdate_no_trackrrC _update_staterM_initialize_persistence)r>r)current_conversations stored_datarstateoutrur4r4r5rRs2       z+ConversationHandler._initialize_persistencer,cCs|j}|j}g}|jr|durtd||j|jr*|dur$td||j|jrM|jdur6td|jj rE||jj t |S||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_userrdr?appendidrerfcallback_queryinline_message_idmessage message_idtuple)r>r,chatuserrr4r4r5_get_keys&   zConversationHandler._get_keyrr-contextr+c sZz|IdH}Wnty"}ztjd|dWYd}~dSd}~ww|j|||||dS)NzTNon-blocking handler callback raised exception. Not scheduling conversation timeout.exc_info)rr)r,rr+) ExceptionrAdebug _schedule_job)r>rr)r,rr+effective_new_staterDr4r4r5_schedule_job_delayeds$z)ConversationHandler._schedule_job_delayedc Cst||jkrdSz|j}|j|j|jt||||d|j|<WdSty9}ztj d|dWYd}~dSd}~ww)zRSchedules a job which executes :meth:`_trigger_timeout` upon conversation timeout.N)datazFailed to schedule timeout.r) rC job_queuerun_once_trigger_timeoutrgr(rZrrAr@)r>rr)r,rr+j_queuerDr4r4r5rs  z!ConversationHandler._schedule_jobc Cst|tsdS|js |jrdS|jr|jsdS|jr|jsdS|jr'|j s'dS|j r3|jr3|j j s3dS| |}|j |}d}t|trtd|rs|}|jdurf|jrf|j |dd}n2||||j |}n%|j |jg}|D]}||}|dur|dur|j|||fSq}dStdt|t|d}|dus|jr|jD]} | |}|dur|dur| }nq|durdS|dur |dur |j |gD]} | |}|dur|dur| }nq|jD]} | |}|dur|dur| }nqdS||||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)rsr channel_postedited_channel_postrdrrerrfrrrrOgetr6rArr<rFr8r9r@poprrar_ check_updaterrcr`rb) r>r,rrcheckrEhandlershandler_ru entry_point candidatefallbackr4r4r5rsr                 z ConversationHandler.check_updatez)Application[Any, CCT, Any, Any, Any, Any] check_resultc s`|\}}}}d} |j4IdH|j|d} | dur | WdIdHn 1IdHs0wY|jtur>|j} n!|jturG|j} nt|jt rY|jj durY|jj j} nt |j} z#| rn| ||||IdH} n|j| |||||d|jdd} Wnty} z | j} d} WYd} ~ nd} ~ ww|j4IdHJ|jr|jdurtddd n0|jjjstd dd n$t| tjr|j|| |||||d|jd d n || ||||WdIdHn 1IdHswYt|jtr| |jvr||j||| rt|j| |j| S||j kr)|| ||| r.tdS) 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,rhTzHIgnoring `conversation_timeout` because the Application has no JobQueue.rqzQIgnoring `conversation_timeout` because the Applications JobQueue is not running.z:handle_update:timeout_job)r,rh)!rYrZrschedule_removalrkrrLrsbotrdefaultsr get_value handle_update create_task update_idrrrgrr schedulerrunningrGrHrrrjrrrCrr_)r>r,r)rr current_stater+ruhandler_check_resultraise_dp_handler_stop timeout_jobrkrr@r4r4r5r-s (           (  z!ConversationHandler.handle_updaterrucCs||jkr||jvr|j|=dSdSt|tjr't|j||d|j|<dS|durZ||jvrSt|dur;t |j j ndd|d|j durKd|j ndddd ||j|<dSdS) Nr7rz returned state z, which is unknown to the ConversationHandler rwrprq) rCrOrsrGrHr6rrarreprcallbackr.rh)r>rrrur4r4r5rs(      z!ConversationHandler._update_statec s(td|j}tt|j}td|j|j}|j4IdH'|j |j}||ur6 WdIdHdS|j |j=WdIdHn 1IdHsKwY|j |j g}|D]/}| |j}|dur|durz||j|j||IdHWqZtytdddYqZwqZ||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. r$z7Conversation timeout was triggered for conversation %s!NFzWApplicationHandlerStop in TIMEOUT state of ConversationHandler has no effect. Ignoring.rprq)rjobr(rrArr+r*rYrZrrar]rr,rr)rrrrC) r>rrctxtr* found_jobrrurr4r4r5rs<   (    z$ConversationHandler._trigger_timeoutr;)7r.r/r0r1r2rCrintr3r]r_rrrrr rIrrJr r floatdatetime timedeltarrrrpropertyr`setterr rarbrcrerdrfrgrhrirjrr"rrrGrHrr_CheckUpdateTyperrrrr4r4r4r5r&zs*       &   4  [ e )Br1rGr dataclassesrtypingrrrrrrr r r r r rtelegramrtelegram._utils.defaultvaluerrtelegram._utils.loggingrtelegram._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.typesr r!r"rxr#r$r%rIrr.rAr(r6r&r4r4r4r5s> 8                 ,