o
    "hA                     @   s  d Z ddlZddlZddlmZ ddlmZmZm	Z	m
Z
mZmZmZmZ ddlmZ ddlmZmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddl m!Z! ddl"m#Z# ddl$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2m3Z3 erddl4m5Z5m6Z6m7Z7 e8e9e3e!ee1e9f e9f Z:ee;ddZ<eG dd de
e1 Z=eG dd dZ>G dd de!ee1e9f Z?dS )z-This module contains the ConversationHandler.    N)	dataclass)TYPE_CHECKINGAnyFinalGenericNoReturnOptionalUnioncast)Update)DEFAULT_TRUEDefaultValue)
get_logger)build_repr_with_selected_attrs)DVType)warn)ApplicationHandlerStop)ExtBot)BaseHandler)CallbackQueryHandler)ChosenInlineResultHandler)InlineQueryHandler)StringCommandHandler)StringRegexHandler)TypeHandler)TrackingDict)CCTConversationDictConversationKey)ApplicationJobJobQueueConversationHandler)
class_namec                   @   s6   e Zd ZU dZdZeed< eed< ded< eed< dS )	_ConversationTimeoutContextzUsed as a datastore for conversation timeouts. Passed in the
    :paramref:`JobQueue.run_once.data` parameter. See :meth:`_trigger_timeout`.
    )applicationcallback_contextconversation_keyupdater'   r(   .Application[Any, CCT, Any, Any, Any, JobQueue]r%   r&   N)	__name__
__module____qualname____doc__	__slots__r   __annotations__r   r    r0   r0   ]/var/www/html/venv/lib/python3.10/site-packages/telegram/ext/_handlers/conversationhandler.pyr$   2   s   
 r$   c                   @   sD   e Zd ZU dZdZejed< eed< de	fddZ
defdd	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_statetaskr5   r4   returnc                 C   s
   | j  S N)r5   doneselfr0   r0   r1   r8   L   s   
zPendingState.donec                 C   sl   | j  s	td| j  }|rtd| j | jS | j  }|du r-| jdu r-tj}|S |du r4| jS |S )a  Returns 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.
        zNew state is not yet availablez<Task function raised exception. Falling back to old state %sN)	r5   r8   RuntimeError	exception_LOGGERr4   resultr"   END)r:   excresr0   r0   r1   resolveO   s    
	

zPendingState.resolveN)r*   r+   r,   r-   r.   asyncioTaskr/   objectboolr8   rB   r0   r0   r0   r1   r2   @   s   
 
r2   c                   @   s  e Zd ZU dZdZdZee ed< 	 dZ	ee ed< 	 dZ
ee ed< 	 d	d
d
d	ddd	def	dddeeeeef  deeeeeeef  f deeeeef  dededededeeeejf  dee dedeeeef  dee fddZdefddZedeeeeef  fdd Zejd!edefd"d Zedeeeeeeef  f fd#d$Z e jd!edefd%d$Z edeeeeef  fd&d'Z!e!jd!edefd(d'Z!edefd)d*Z"e"jd!edefd+d*Z"edefd,d-Z#e#jd!edefd.d-Z#edefd/d0Z$e$jd!edefd1d0Z$edefd2d3Z%e%jd!edefd4d3Z%edeeeejf  fd5d6Z&e&jd!edefd7d6Z&edee fd8d9Z'e'jd!edefd:d9Z'edefd;d<Z(e(jd!edefd=d<Z(edeeeef  fd>d?Z)e)jd!edefd@d?Z)dAdBdeee*e+ef f fdCdDZ,dEede+fdFdGZ-dHe.j/dAdIdEedJedKe+ddfdLdMZ0dHedAdIdEedJedKe+ddfdNdOZ1dEedee2e  fdPdQZ3dEedAdRdSe2e dJedee f
dTdUZ4	d\dHedVe+dWee ddfdXdYZ5dJeddfdZd[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 <per_message>`, :class:`ConversationHandler` uses
        :attr:`update.callback_query.message.message_id <telegram.Message.message_id>` when
        :attr:`per_chat=True <per_chat>` and
        :attr:`update.callback_query.inline_message_id <.CallbackQuery.inline_message_id>` when
        :attr:`per_chat=False <per_chat>`. 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 <block>` 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 <examples.conversationbot>`
        * :any:`Conversation Bot 2 <examples.conversationbot2>`
        * :any:`Nested Conversation Bot <examples.nestedconversationbot>`
        * :any:`Persistent Conversation Bot <examples.persistentconversationbot>`

    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_jobsr?   TIMEOUTWAITINGFTNr:   zConversationHandler[CCT]entry_pointsstates	fallbacksallow_reentryper_chatper_userper_messageconversation_timeoutname
persistentmap_to_parentblockc                 C   s6  ddl m}m}m}m} d| _|| _|| _|| _|| _	|| _
|| _|| _|| _|| _|	| _|| _i | _t | _i | _t | _|
rH| jsHtd|
| _t| j| j| jfsYtd| jre| jsetddd g }| | | | |! D ]}| | qu| j"d	d
 |D  d}|D ]}t#|t$t%frtd|j&j' ddd net#|t(rt)|j*t+std|j*j' ddd nMt#||rtddd nA| jrt#||t,t-||frtd|j&j' d| dd n%| jrt#|t.std| dd n| jst#|t.rtd| dd | j/rt#|| j&rtddd qd S )Nr   )PollAnswerHandlerPollHandlerPreCheckoutQueryHandlerShippingQueryHandlerTz: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.   
stacklevelc                 s   s    | ]
}t |tr|V  qd S r7   )
isinstancer"   ).0handlerr0   r0   r1   	<genexpr>b  s    

z/ConversationHandler.__init__.<locals>.<genexpr>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`?zUpdates 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.extrh   ri   rj   rk   rg   rH   rL   rT   rM   rG   rR   rP   rQ   rJ   rO   rN   rV   rC   LockrU   rK   setrI   rd   
ValueErrorrS   anyra   r`   rb   r   extendvaluesr(   ro   r   r   	__class__r*   r   
issubclasstyper   r   r   r   rc   )r:   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   all_handlersstate_handlersper_faq_linkrq   r0   r0   r1   __init__  s   	




zConversationHandler.__init__r6   c                 C   sT   d}t t| j d| }t|}t| j|kr"|dd d }t| | j|dS )a  Give 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`
           NrW   z, ...})rd   r]   )dictlistr]   itemsstrlenr   rd   )r:   truncation_thresholdr]   states_stringr0   r0   r1   __repr__  s   zConversationHandler.__repr__c                 C      | j S )zlist[:class:`telegram.ext.BaseHandler`]: A list of :obj:`BaseHandler` objects that can
        trigger the start of the conversation.
        )rL   r9   r0   r0   r1   r\     s   z ConversationHandler.entry_points_c                 C      t d)NzDYou can not assign a new value to entry_points after initialization.AttributeErrorr:   r   r0   r0   r1   r\        c                 C   r   )a   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.
        )rT   r9   r0   r0   r1   r]        zConversationHandler.statesc                 C   r   )Nz>You can not assign a new value to states after initialization.r   r   r0   r0   r1   r]        c                 C   r   )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`.
        )rM   r9   r0   r0   r1   r^     r   zConversationHandler.fallbacksc                 C   r   )NzAYou can not assign a new value to fallbacks after initialization.r   r   r0   r0   r1   r^     r   c                 C   r   )zQ:obj:`bool`: Determines if a user can restart a conversation with an entry point.)rG   r9   r0   r0   r1   r_        z!ConversationHandler.allow_reentryc                 C   r   )NzEYou can not assign a new value to allow_reentry after initialization.r   r   r0   r0   r1   r_     r   c                 C   r   )zB:obj:`bool`: If the conversation key should contain the User's ID.)rR   r9   r0   r0   r1   ra     r   zConversationHandler.per_userc                 C   r   )Nz@You can not assign a new value to per_user after initialization.r   r   r0   r0   r1   ra     r   c                 C   r   )zB:obj:`bool`: If the conversation key should contain the Chat's ID.)rP   r9   r0   r0   r1   r`     r   zConversationHandler.per_chatc                 C   r   )Nz@You can not assign a new value to per_chat after initialization.r   r   r0   r0   r1   r`     r   c                 C   r   )zE:obj:`bool`: If the conversation key should contain the message's ID.)rQ   r9   r0   r0   r1   rb     r   zConversationHandler.per_messagec                 C   r   )NzCYou can not assign a new value to per_message after initialization.r   r   r0   r0   r1   rb     r   c                 C   r   )z:obj:`float` | :obj:`datetime.timedelta`: Optional. When this
        handler is inactive more than this timeout (in seconds), it will be automatically
        ended.
        )rJ   r9   r0   r0   r1   rc     s   z(ConversationHandler.conversation_timeoutc                 C   r   )NzLYou can not assign a new value to conversation_timeout after initialization.r   r   r0   r0   r1   rc     r   c                 C   r   )zE:obj:`str`: Optional. The name for this :class:`ConversationHandler`.)rO   r9   r0   r0   r1   rd      r   zConversationHandler.namec                 C   r   )Nz<You can not assign a new value to name after initialization.r   r   r0   r0   r1   rd   %  r   c                 C   r   )z:obj:`bool`: Optional. If the conversations dict for this handler should be
        saved. :attr:`name` is required and persistence has to be set in
        :attr:`Application <.Application.persistence>`.
        )rS   r9   r0   r0   r1   re   )  r   zConversationHandler.persistentc                 C   r   )NzBYou can not assign a new value to persistent after initialization.r   r   r0   r0   r1   re   1  r   c                 C   r   )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.
        )rN   r9   r0   r0   r1   rf   5  r   z!ConversationHandler.map_to_parentc                 C   r   )NzEYou can not assign a new value to map_to_parent after initialization.r   r   r0   r0   r1   rf   =  r   r%   r   c                    s   | j r
| jr
|jstd| j}tdt | _| j| |j| jI dH }| j	| |
 D ]\}}|| jkrC| j| j|d q2| j| ji}| jD ]}||j|dI dH  qM|S )a  Initializes 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_statekey)r%   )re   rd   persistencer;   rK   r
   r   r(   get_conversationsupdate_no_trackr   r?   _update_staterI   _initialize_persistence)r:   r%   current_conversationsstored_datar   stateoutrq   r0   r0   r1   r   C  s2   


z+ConversationHandler._initialize_persistencer(   c                 C   s   |j }|j}g }| jr|du rtd||j | jr*|du r$td||j | jrM|jdu r6td|jj	rE||jj	 t|S ||jj
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_chateffective_userr`   r;   appendidra   rb   callback_queryinline_message_idmessage
message_idtuple)r:   r(   chatuserr   r0   r0   r1   _get_keyw  s&   
zConversationHandler._get_keyr   r)   contextr'   c              
      sZ   z|I d H }W n t y" } ztjd|d W Y d }~d S d }~ww | j|||||dS )NzTNon-blocking handler callback raised exception. Not scheduling conversation timeout.exc_info)r   r%   r(   r   r'   )	Exceptionr=   debug_schedule_job)r:   r   r%   r(   r   r'   effective_new_stater@   r0   r0   r1   _schedule_job_delayed  s$   z)ConversationHandler._schedule_job_delayedc              
   C   st   || j krdS z|j}|j| j| jt||||d| j|< W dS  ty9 } ztj	d|d W Y d}~dS d}~ww )zRSchedules a job which executes :meth:`_trigger_timeout` upon conversation timeout.N)datazFailed to schedule timeout.r   )
r?   	job_queuerun_once_trigger_timeoutrc   r$   rV   r   r=   r<   )r:   r   r%   r(   r   r'   j_queuer@   r0   r0   r1   r     s   
	z!ConversationHandler._schedule_jobc                 C   s  t |tsdS |js|jrdS | jr|jsdS | jr|jsdS | jr'|j	s'dS |j	r3| jr3|j	j
s3dS | |}| j|}d}t |trtd | rs| }|jdu rf|j rf| j|d d}n2| || | j|}n%| j| jg }|D ]}||}|dur|dur| j|||f  S q}dS tdt|t| d}|du s| jr| jD ]}	|	|}|dur|dur|	} nq|du rdS |dur	|du r	| j|g D ]}
|
|}|dur|dur|
} nq| jD ]}||}|dur|dur|} nqdS ||||fS )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)ro   r   channel_postedited_channel_postr`   r   ra   r   rb   r   r   r   rK   getr2   r=   r   r8   rB   r4   r5   r<   popr   r]   r[   check_updater   r_   r\   r^   )r:   r(   r   r   checkrA   handlershandler_rq   entry_point	candidatefallbackr0   r0   r1   r     sr   









z ConversationHandler.check_updatez)Application[Any, CCT, Any, Any, Any, Any]check_resultc              
      s`  |\}}}}d}	| j 4 I dH  | j|d}
|
dur |
  W d  I dH  n1 I dH s0w   Y  |jtur>|j}n!| jturG| j}nt|jt	rY|jj
durY|jj
j}nt|j}z#|rn|||||I dH }n|j||||||d|j dd}W n ty } z|j}d}	W Y d}~nd}~ww | j 4 I dH J | jr|jdu rtddd	 n0|jjjstd
dd	 n$t|tjr|j| ||||||d|j dd n	| ||||| W d  I dH  n1 I dH sw   Y  t| jtr|| jv r| | j|| |	rt| j|| j|S || j kr)| ||| |	r.tdS )aL  Send 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.

        FNzConversationHandler:z:handle_update:non_blocking_cb)	coroutiner(   rd   TzHIgnoring `conversation_timeout` because the Application has no JobQueue.   rm   zQIgnoring `conversation_timeout` because the Applications JobQueue is not running.z:handle_update:timeout_job)r(   rd   )!rU   rV   r   schedule_removalrg   r   rH   ro   botr   defaultsr   	get_valuehandle_updatecreate_task	update_idr   r   rc   r   r   	schedulerrunningrC   rD   r   r   rf   r   r   r?   r   r[   )r:   r(   r%   r   r   current_stater'   rq   handler_check_resultraise_dp_handler_stoptimeout_jobrg   r   r<   r0   r0   r1   r     s   (




(z!ConversationHandler.handle_updater   rq   c                 C   s   || j kr|| jv r| j|= d S d S t|tjr't| j||d| j|< d S |d urZ|| jvrSt|d ur;t	|j
jnd d| d| jd urKd| j nd ddd	 || j|< d S d S )
Nr3   r   z returned state z, which is unknown to the ConversationHandler  rs   rl   rm   )r?   rK   ro   rC   rD   r2   r   r]   r   reprcallbackr*   rd   )r:   r   r   rq   r0   r0   r1   r     s(   


z!ConversationHandler._update_statec           	   	      s(  t d|j}t d|j}td|j |j}| j4 I dH ' | j	|j}||ur6	 W d  I dH  dS | j|j= W d  I dH  n1 I dH sKw   Y  | j
	| jg }|D ]/}||j}|dur|durz||j|j||I dH  W qZ ty   tddd Y qZw qZ| | j|j dS )	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    r$   z7Conversation timeout was triggered for conversation %s!NFzWApplicationHandlerStop in TIMEOUT state of ConversationHandler has no effect. Ignoring.rl   rm   )r
   jobr   r=   r   r'   r&   rU   rV   r   r]   rY   r   r(   r   r%   r   r   r   r?   )	r:   r   r   ctxtr&   	found_jobr   rq   r   r0   r0   r1   r     s<   (
z$ConversationHandler._trigger_timeoutr7   )7r*   r+   r,   r-   r.   r?   r   intr/   rY   r[   r   r   r   r   r   rE   r   rF   r   r	   floatdtm	timedeltar   r   r   r   propertyr\   setterr   r]   r^   r_   ra   r`   rb   rc   rd   re   rf   r   r   r   r   rC   rD   r   r   _CheckUpdateTyper   r   r   r   r0   r0   r0   r1   r"   m   s*  
  		

 &	
4

[
e
)@r-   rC   datetimer   dataclassesr   typingr   r   r   r   r   r   r	   r
   telegramr   telegram._utils.defaultvaluer   r   telegram._utils.loggingr   telegram._utils.reprr   telegram._utils.typesr   telegram._utils.warningsr   telegram.ext._applicationr   telegram.ext._extbotr   "telegram.ext._handlers.basehandlerr   +telegram.ext._handlers.callbackqueryhandlerr   0telegram.ext._handlers.choseninlineresulthandlerr   )telegram.ext._handlers.inlinequeryhandlerr   +telegram.ext._handlers.stringcommandhandlerr   )telegram.ext._handlers.stringregexhandlerr   "telegram.ext._handlers.typehandlerr    telegram.ext._utils.trackingdictr   telegram.ext._utils.typesr   r   r   rt   r   r    r!   r   rE   r   r*   r=   r$   r2   r"   r0   r0   r0   r1   <module>   s>   (,