YiH %SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ r SSK J r J r J r JrJr SSKJr SSKJr SSKJrJr SSKJrJrJrJrJrJrJrJr SS K J!r! SS K"J#r#J$r$J%r%J&r&J'r' SS K(J)r) SS K*J+r+ SS K,J-r-J.r.J/r/ SSK0J1r1 SSK2J3r3 SSK4J5r5 SSK6J7r7 SSK8J9r9 SSK:J;r; SSKJ?r? SSK@JArA SSKBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrK SSKLJMrM \(a&SSKNJNrN SSKOJPrP SSKQJRrRJSrS SSKTJUrU SSKVJWrW SSKXJYrY SrZ\[\\S'\"S S!S"9r]\^"5r_\'"S5r`\RS#:a\ \HrbO\\ S$S\H4\ \H4rb\\b\Hrc\)"\d5re"S%S&\f5rg"S'S!\\D\E\I\F\C\G4\RS!5rig)(z+This module contains the Application class.N) defaultdict) Awaitable Coroutine GeneratorMappingSequence)deepcopy)Path)MappingProxyType TracebackType) TYPE_CHECKINGAnyCallableGenericNoReturnOptionalTypeVarUnion)Update) DEFAULT_80 DEFAULT_IP DEFAULT_NONE DEFAULT_TRUE DefaultValue) get_logger)build_repr_with_selected_attrs)SCTDVTypeODVInput)warn) TelegramError)BasePersistence) ContextTypes)ExtBot) BaseHandler)Updater) was_called_by) TrackingDict) BDBTCCTCDJQRTUDConversationKeyHandlerCallback)PTBDeprecationWarning)socket)Message)ConversationHandlerJobQueue)InitApplicationBuilder)BaseUpdateProcessor)Job DEFAULT_GROUP_AppType Application)bound zasyncio.Future[object]cF^\rSrSrSrSrSS\\SS4U4SjjjrSr U=r $) ApplicationHandlerStopUa Raise this in a handler or an error handler to prevent execution of any other handler (even in different groups). In order to use this exception in a :class:`telegram.ext.ConversationHandler`, pass the optional :paramref:`state` parameter instead of returning the next state: .. code-block:: python async def conversation_callback(update, context): ... raise ApplicationHandlerStop(next_state) Note: Has no effect, if the handler or error handler is run in a non-blocking way. Args: state (:obj:`object`, optional): The next state of the conversation. Attributes: state (:obj:`object`): Optional. The next state of the conversation. )stateNrDreturnc.>[TU]5 XlgN)super__init__rD)selfrD __class__s D/app/.venv/lib/python3.13/site-packages/telegram/ext/_application.pyrIApplicationHandlerStop.__init__os ', rG) __name__ __module__ __qualname____firstlineno____doc__ __slots__robjectrI__static_attributes__ __classcell__)rKs@rLrBrBUs,.I-hv.-$--rNrBc#\rSrSrSr\R S:aSOSrSSS\S S S \ \ S \ S SS\ \ \ \\4S\\\ \\4S\ \S/\\\S44S\ \S/\\\S44S\ \S/\\\S444SjrS\S\4SjrS\ \\S\ \S\ \SS4SjrS\4Sjr\S\4Sj5r \S\!4Sj5r"\S\ S4S j5r#\S}S!j5r$\%S\&4S"j5r'\%S~S#j5r(SS$jr)SS%jr*SS'jr+SS(jr,SS)jr-SS*jr.SS+jr/SS,jr0S-S.S/\1\1\1\1SSS0\14 S1\2S2\!S3\!S4\3\2S5\3\2S6\3\2S7\3\2S8\ \4\S9\ \S:\S;\3\4\!SS4S<jjr5\6\7S=SSS>SSSSS?S0\1SS4S@\8\SA\8\!SB\SC\ \9\\:4SD\ \9\\:4S3\!SE\ \S8\ \4\S9\ \SF\ \SG\!S:\S;\3\4\!SH\ \SI\ \9\\:SJ4SS4 SKjjr;SSL\S;\3\4\!S:\SS4SMjjr<SSSN.SO\=\>SP\ \?SQ\ \SSR4SSjjjr@SSO\=\>SP\ \?ST\SQ\ \SSR4 SUjjrASV\BRSS4SWjrDSSO\=\>SP\ \?ST\S\>4SXjjrESSYjrFSSZjrGSP\?SS4S[jrHSP\?SS4S\jrI\J4S&\K\\\4S]\!SS4S^jjrL\M4S_\9\4\K\\\4\N\!\4\K\\\444S]\9\!\O\!4SS4S`jjrP\J4S&\K\\\4S]\!SS4SajjrQSb\!SS4ScjrRSd\!SS4SejrSSSf\ SgSh\ \!Si\ \!SS4SjjjrTSSSk.SP\ \?Sl\ SmSS4SnjjrUSSo\ \V\!Sp\ \V\!SS4SqjjrWSSrjrXSSsjrYSStjrZ\[4Su\\\?\S4Sv\8\SS4Swjjr]Su\\\?\S4SS4Sxjr^SSP\ \?Sy\_Sl\ SzSO\ \`\>S\4 S{jjraS|rbg)r<ta1This class dispatches all kinds of updates to its registered handlers, and is the entry point to a PTB application. Tip: This class may not be initialized directly. Use :class:`telegram.ext.ApplicationBuilder` or :meth:`builder` (for convenience). Instances of this class can be used as asyncio context managers, where .. code:: python async with application: # code is roughly equivalent to .. code:: python try: await application.initialize() # code finally: await application.shutdown() .. seealso:: :meth:`__aenter__` and :meth:`__aexit__`. This class is a :class:`~typing.Generic` class and accepts six type variables: 1. The type of :attr:`bot`. Must be :class:`telegram.Bot` or a subclass of that class. 2. The type of the argument ``context`` of callback functions for (error) handlers and jobs. Must be :class:`telegram.ext.CallbackContext` or a subclass of that class. This must be consistent with the following types. 3. The type of the values of :attr:`user_data`. 4. The type of the values of :attr:`chat_data`. 5. The type of :attr:`bot_data`. 6. The type of :attr:`job_queue`. Must either be :class:`telegram.ext.JobQueue` or a subclass of that or :obj:`None`. Examples: :any:`Echo Bot ` .. seealso:: :wiki:`Your First Bot `, :wiki:`Architecture Overview ` .. versionchanged:: 20.0 * Initialization is now done through the :class:`telegram.ext.ApplicationBuilder`. * Removed the attribute ``groups``. Attributes: bot (:class:`telegram.Bot`): The bot object that should be passed to the handlers. update_queue (:class:`asyncio.Queue`): The synchronized queue that will contain the updates. updater (:class:`telegram.ext.Updater`): Optional. The updater used by this application. chat_data (:obj:`types.MappingProxyType`): A dictionary handlers can use to store data for the chat. For each integer chat id, the corresponding value of this mapping is available as :attr:`telegram.ext.CallbackContext.chat_data` in handler callbacks for updates from that chat. .. versionchanged:: 20.0 :attr:`chat_data` is now read-only. Note that the values of the mapping are still mutable, i.e. editing ``context.chat_data`` within a handler callback is possible (and encouraged), but editing the mapping ``application.chat_data`` itself is not. .. tip:: * Manually modifying :attr:`chat_data` is almost never needed and unadvisable. * Entries are never deleted automatically from this mapping. If you want to delete the data associated with a specific chat, e.g. if the bot got removed from that chat, please use :meth:`drop_chat_data`. user_data (:obj:`types.MappingProxyType`): A dictionary handlers can use to store data for the user. For each integer user id, the corresponding value of this mapping is available as :attr:`telegram.ext.CallbackContext.user_data` in handler callbacks for updates from that user. .. versionchanged:: 20.0 :attr:`user_data` is now read-only. Note that the values of the mapping are still mutable, i.e. editing ``context.user_data`` within a handler callback is possible (and encouraged), but editing the mapping ``application.user_data`` itself is not. .. tip:: * Manually modifying :attr:`user_data` is almost never needed and unadvisable. * Entries are never deleted automatically from this mapping. If you want to delete the data associated with a specific user, e.g. if that user blocked the bot, please use :meth:`drop_user_data`. bot_data (:obj:`dict`): A dictionary handlers can use to store data for the bot. persistence (:class:`telegram.ext.BasePersistence`): The persistence class to store data that should be persistent over restarts. handlers (dict[:obj:`int`, list[:class:`telegram.ext.BaseHandler`]]): A dictionary mapping each handler group to the list of handlers registered to that group. .. seealso:: :meth:`add_handler`, :meth:`add_handlers`. error_handlers (dict[:term:`coroutine function`, :obj:`bool`]): A dictionary where the keys are error handlers and the values indicate whether they are to be run blocking. .. seealso:: :meth:`add_error_handler` context_types (:class:`telegram.ext.ContextTypes`): Specifies the types used by this dispatcher for the ``context`` argument of handler and job callbacks. post_init (:term:`coroutine function`): Optional. A callback that will be executed by :meth:`Application.run_polling` and :meth:`Application.run_webhook` after initializing the application via :meth:`initialize`. post_shutdown (:term:`coroutine function`): Optional. A callback that will be executed by :meth:`Application.run_polling` and :meth:`Application.run_webhook` after shutting down the application via :meth:`shutdown`. post_stop (:term:`coroutine function`): Optional. A callback that will be executed by :meth:`Application.run_polling` and :meth:`Application.run_webhook` after stopping the application via :meth:`stop`. .. versionadded:: 20.1 )r? )__create_task_tasks__update_fetcher_task__update_persistence_event__update_persistence_lock__update_persistence_task__stop_running_marker _chat_data&_chat_ids_to_be_deleted_in_persistence&_chat_ids_to_be_updated_in_persistence#_conversation_handler_conversations _initialized _job_queue_running_update_processor _user_data&_user_ids_to_be_deleted_in_persistence&_user_ids_to_be_updated_in_persistencebotbot_data chat_data context_typeserror_handlershandlers persistence post_init post_shutdown post_stop update_queueupdater user_data __weakref__rJz$Application[BT, CCT, UD, CD, BD, JQ]rlrvzasyncio.Queue[object]rw job_queueupdate_processorr8rrrorsNrtruc T[[R"5[[5R R 5S- 5(d [SSS9 XlX l Xpl X0l 0Ul 0Ul UUlU UlU UlXPlURR%5Ul['URR(5Ul['URR,5Ul[1UR*5Ul[1UR.5UlSUlU(a [5U[65(d [9S5eX`l[;5Ul[;5Ul[;5Ul [;5Ul!0Ul"SUl#SUl$X@l%SUl&SUl'[PRR"5Ul*[PRV"5Ul,[;5Ul-[PRR"5Ul.g)Nz_applicationbuilder.pyzE`Application` instances should be built via the `ApplicationBuilder`. stacklevelz9persistence must be based on telegram.ext.BasePersistenceF)/r'inspect currentframer __file__parentresolver rlrvrorwrqrprsrtrurhrmrrxrirnrar rr isinstancer" TypeErrorsetrcrkrbrjrdrergrf!_Application__update_fetcher_task%_Application__update_persistence_taskasyncioEvent&_Application__update_persistence_eventLock%_Application__update_persistence_lock_Application__create_task_tasks!_Application__stop_running_marker) rJrlrvrwr{r|rrrorsrtrus rLrIApplication.__init__s(  "DN$9$9$A$A$CF^$^   W  3?` the App. Returns: The initialized App instance. Raises: :exc:`Exception`: If an exception is raised during initialization, :meth:`shutdown` is called in this case. N) initialize ExceptionshutdownrJs rL __aenter__Application.__aenter__gsF //# # # $ --/ ! !  s/A  A AAAAexc_typeexc_valexc_tbc@# UR5IShvN gN7f)z>|async_context_manager| :meth:`shuts down ` the App.N)r)rJrrrs rL __aexit__Application.__aexit__xsmmos c([XRS9$)zGive a string representation of the application in the form ``Application[bot=...]``. As this class doesn't implement :meth:`object.__str__`, the default implementation will be used, which is equivalent to :meth:`__repr__`. Returns: :obj:`str` )rl)rrlrs rL__repr__Application.__repr__s.dAArNcUR$)ze:obj:`bool`: Indicates if this application is running. .. seealso:: :meth:`start`, :meth:`stop` )rgrs rLrunningApplication.runnings}}rNc.URR$)aj:obj:`int`: The number of concurrent updates that will be processed in parallel. A value of ``0`` indicates updates are *not* being processed concurrently. .. versionchanged:: 20.4 This is now just a shortcut to :attr:`update_processor.max_concurrent_updates `. .. seealso:: :wiki:`Concurrency` )rhmax_concurrent_updatesrs rLconcurrent_updatesApplication.concurrent_updatess%%<<` zqNo `JobQueue` set up. To use `JobQueue`, you must install PTB via `pip install "python-telegram-bot[job-queue]"`.r~r)rfr rs rLr{Application.job_queues+ ?? " B  rNcUR$)z:class:`telegram.ext.BaseUpdateProcessor`: The update processor used by this application. .. seealso:: :wiki:`Concurrency` .. versionadded:: 20.4 )rhrs rLr|Application.update_processors%%%rNc[erG) SystemExitrzrNrL_raise_system_exitApplication._raise_system_exitsrNcSSKJn U"5$)zdConvenience method. Returns a new :class:`telegram.ext.ApplicationBuilder`. .. versionadded:: 20.0 rApplicationBuilder) telegram.extrrs rLbuilderApplication.builders 4!##rNc<UR(d [S5eg)NzBThis Application was not initialized via `Application.initialize`!)re RuntimeErrorrs rL_check_initializedApplication._check_initializeds   T !rNc.# UR(a[RS5 gURR 5IShvN UR R 5IShvN UR (a"UR R 5IShvN UR(dSUlgUR5IShvN SSK J n [RRURR55HTn[!X!5(dMUR"(dM(UR$(dM;UR'U5IShvN MV SUlUR(R+5 gGNBGN#NNN47f)aInitializes the Application by initializing: * The :attr:`bot`, by calling :meth:`telegram.Bot.initialize`. * The :attr:`updater`, by calling :meth:`telegram.ext.Updater.initialize`. * The :attr:`persistence`, by loading persistent conversations and data. * The :attr:`update_processor` by calling :meth:`telegram.ext.BaseUpdateProcessor.initialize`. Does *not* call :attr:`post_init` - that is only done by :meth:`run_polling` and :meth:`run_webhook`. .. seealso:: :meth:`shutdown` z(This Application is already initialized.NTrr5)re_LOGGERdebugrlrrhrwrr_initialize_persistence*telegram.ext._handlers.conversationhandlerr5 itertoolschain from_iterablerqvaluesr persistentname_add_ch_to_persistencerclear)rJr5handlers rLrApplication.initializes)    MMD E hh!!###$$//111 <<,,))+ + + $D  **,,, S!44T]]5I5I5KLG'77G9=E6E7!EE"E<E>EEEc# UR(dgURRR(a;URR URR 5IShvN 5 URRR (a;URR URR5IShvN 5 URRR(aURR5IShvN Ul [URURR5(d,[SURRR35eURRR(aUR R"b{URR%5IShvN nUbU[U[&5(a[)U5S:wa [S5eUR R"R+U5 ggggGNGNlGN$Nh7f)zHThis method basically just loads all the data by awaiting the BP methodsNzbot_data must be of type r~z)callback_data must be a tuple of length 2)rr store_datarxrir get_user_datarnra get_chat_datarm get_bot_datarro ValueErrorrO callback_datarlcallback_data_cacheget_callback_datatuplelenload_persistence_data)rJpersistent_datas rLr#Application._initialize_persistence+s     & & 0 0 OO " ")9)9)G)G)I#I J    & & 0 0 OO " ")9)9)G)G)I#I J    & & / /"&"2"2"?"?"AADMdmmT-?-?-H-HII /0B0B0K0K0T0T/UV    & & 4 4 HH ( ( 4$($4$4$F$F$HHO*!/599S=QUV=V$%PQQ,,BB#+ 5 5$J#IAIsLA*I,H5-AI H8 A IH;B=IH>A I8I;I>Ic# UR(a [S5eUR5 SUlURR 5 UR (aU[R"UR5SURRS3S9Ul [RS5 UR(a7URR!5IShvN [RS5 [R"UR#5SURRS 3S9Ul[R'S 5 gNo![(a S Ulef=f7f) aYStarts * a background task that fetches updates from :attr:`update_queue` and processes them via :meth:`process_update`. * :attr:`job_queue`, if set. * a background task that calls :meth:`update_persistence` in regular intervals, if :attr:`persistence` is set. Note: This does *not* start fetching updates from Telegram. To fetch updates, you need to either start :attr:`updater` manually or use one of :meth:`run_polling` or :meth:`run_webhook`. Tip: When using a custom logic for startup and shutdown of the application, eventual cancellation of pending tasks should happen only `after` :meth:`stop` has been called in order to ensure that the tasks mentioned above are not cancelled prematurely. .. seealso:: :meth:`stop` Raises: :exc:`RuntimeError`: If the application is already running or was not initialized. z$This Application is already running!T Application:z:persistence_updaterrz%Loop for updating persistence startedNzJobQueue startedz:update_fetcherzApplication startedF)rrrrgrrrrr create_task_persistence_updaterrlidrrrrfstart_update_fetcherrinforrs rLrApplication.startHs2 <<EF F !  ''--/ 181D1D--/' }4HI2. EFoo++--- 01)0)<)<$$&|DHHKK=-X*D & LL. / . !DM  s2AE-BE%E&A.EE-EE**E-c*# UR(d [S5eSUlURR 5 [ R S5 UR(aURR5(aURR5 OrURR[5IShvN [ RS5 URR!5IShvN URIShvN [ RS 5 UR"(aK[ RS 5 UR"R%SS 9IShvN [ RS 5 [ RS 5 [&R("UR*SS06IShvN UR,(anUR.(a][ RS5 UR0R35 UR.IShvN UR0R 5 [ R S5 g![a n[ RSUSS9 SnAGNhSnAff=fGNGNGN{GN"NNo7f)aStops the process after processing any pending updates or tasks created by :meth:`create_task`. Also stops :attr:`job_queue`, if set. Finally, calls :meth:`update_persistence` and :meth:`BasePersistence.flush` on :attr:`persistence`, if set. Warning: Once this method is called, no more updates will be fetched from :attr:`update_queue`, even if it's not empty. .. seealso:: :meth:`start` Note: * This does *not* stop :attr:`updater`. You need to either manually call :meth:`telegram.ext.Updater.stop` or use one of :meth:`run_polling` or :meth:`run_webhook`. * Does *not* call :attr:`post_stop` - that is only done by :meth:`run_polling` and :meth:`run_webhook`. Raises: :exc:`RuntimeError`: If the application is not running. z This Application is not running!Fz2Application is stopping. This might take a moment.zZFetching updates was aborted due to %r. Suppressing exception to ensure graceful shutdown.Texc_infoNz Waiting for update_queue to joinz(Application stopped fetching of updates.z"Waiting for running jobs to finish)waitzJobQueue stoppedz/Waiting for `create_task` calls to be processedreturn_exceptionsz&Waiting for persistence loop to finishzApplication.stop() complete)rrrgrrrrrdoneresult BaseExceptioncriticalrvput _STOP_SIGNALrjoinrfstoprgatherrrrrrr)rJexcs rLrApplication.stop}s.||AB B  ""((* IJ  % %))..00..557''++L999 @A'',,...0000 @A ?? MM> ?//&&D&1 1 1 MM, - GHnnd66O$OOO    > > MMB C  + + / / 100 0 0  + + 1 1 3 23;%$$A!% %:.0 2 P 1sBJI #JJ6J:J;JJ AJ*J +AJ<J=A$J!J"4J J I;5J;JJJ J JJJcUR(a$[R"5R5 gURR 5 UR (d[RS5 gg)aThis method can be used to stop the execution of :meth:`run_polling` or :meth:`run_webhook` from within a handler, job or error callback. This allows a graceful shutdown of the application, i.e. the methods listed in :attr:`run_polling` and :attr:`run_webhook` will still be executed. This method can also be called within :meth:`post_init`. This allows for a graceful, early shutdown of the application if some condition is met (e.g., a database connection could not be established). Note: If the application is not running and this method is not called within :meth:`post_init`, this method does nothing. Warning: This method is designed to for use in combination with :meth:`run_polling` or :meth:`run_webhook`. Using this method in combination with a custom logic for starting and stopping the application is not guaranteed to work as expected. Use at your own risk. .. versionadded:: 20.5 .. versionchanged:: 21.2 Added support for calling within :meth:`post_init`. zVApplication is not running and not initialized. `stop_running()` likely has no effect.N) rrget_running_looprrrrerrrs rL stop_runningApplication.stop_runningsS2 <<  $ $ & + + -  & & * * ,$$ !%rNg T poll_intervaltimeoutbootstrap_retries read_timeout write_timeoutconnect_timeout pool_timeoutallowed_updatesdrop_pending_updates close_loop stop_signalsc ^TR(d [S5eXEXg4[4S-:wa[[ SS5SS9 S[ SS 4U4S jjn TR TRRUUUUUUUUU U S 9 U U S 9$) a'Convenience method that takes care of initializing and starting the app, polling updates from Telegram using :meth:`telegram.ext.Updater.start_polling` and a graceful shutdown of the app on exit. |app_run_shutdown| :paramref:`stop_signals`. The order of execution by :meth:`run_polling` is roughly as follows: - :meth:`initialize` - :meth:`post_init` - :meth:`telegram.ext.Updater.start_polling` - :meth:`start` - Run the application until the users stops it - :meth:`telegram.ext.Updater.stop` - :meth:`stop` - :meth:`post_stop` - :meth:`shutdown` - :meth:`post_shutdown` A small wrapper is passed to :paramref:`telegram.ext.Updater.start_polling.error_callback` which forwards errors occurring during polling to :meth:`registered error handlers `. The update parameter of the callback will be set to :obj:`None`. .. include:: inclusions/application_run_tip.rst Args: poll_interval (:obj:`float`, optional): Time to wait between polling updates from Telegram in seconds. Default is ``0.0``. timeout (:obj:`int`, optional): Passed to :paramref:`telegram.Bot.get_updates.timeout`. Default is ``10`` seconds. bootstrap_retries (:obj:`int`, optional): Whether the bootstrapping phase of the :class:`telegram.ext.Updater` will retry on failures on the Telegram server. * < 0 - retry indefinitely (default) * 0 - no retries * > 0 - retry up to X times read_timeout (:obj:`float`, optional): Value to pass to :paramref:`telegram.Bot.get_updates.read_timeout`. Defaults to :attr:`~telegram.request.BaseRequest.DEFAULT_NONE`. .. versionchanged:: 20.7 Defaults to :attr:`~telegram.request.BaseRequest.DEFAULT_NONE` instead of ``2``. .. deprecated:: 20.7 Deprecated in favor of setting the timeout via :meth:`telegram.ext.ApplicationBuilder.get_updates_read_timeout`. write_timeout (:obj:`float` | :obj:`None`, optional): Value to pass to :paramref:`telegram.Bot.get_updates.write_timeout`. Defaults to :attr:`~telegram.request.BaseRequest.DEFAULT_NONE`. .. deprecated:: 20.7 Deprecated in favor of setting the timeout via :meth:`telegram.ext.ApplicationBuilder.get_updates_write_timeout`. connect_timeout (:obj:`float` | :obj:`None`, optional): Value to pass to :paramref:`telegram.Bot.get_updates.connect_timeout`. Defaults to :attr:`~telegram.request.BaseRequest.DEFAULT_NONE`. .. deprecated:: 20.7 Deprecated in favor of setting the timeout via :meth:`telegram.ext.ApplicationBuilder.get_updates_connect_timeout`. pool_timeout (:obj:`float` | :obj:`None`, optional): Value to pass to :paramref:`telegram.Bot.get_updates.pool_timeout`. Defaults to :attr:`~telegram.request.BaseRequest.DEFAULT_NONE`. .. deprecated:: 20.7 Deprecated in favor of setting the timeout via :meth:`telegram.ext.ApplicationBuilder.get_updates_pool_timeout`. drop_pending_updates (:obj:`bool`, optional): Whether to clean any pending updates on Telegram servers before actually starting to poll. Default is :obj:`False`. allowed_updates (Sequence[:obj:`str`], optional): Passed to :meth:`telegram.Bot.get_updates`. .. versionchanged:: 21.9 Accepts any :class:`collections.abc.Sequence` as input instead of just a list close_loop (:obj:`bool`, optional): If :obj:`True`, the current event loop will be closed upon shutdown. Defaults to :obj:`True`. .. seealso:: :meth:`asyncio.loop.close` stop_signals (Sequence[:obj:`int`] | :obj:`None`, optional): Signals that will shut down the app. Pass :obj:`None` to not use stop signals. Defaults to :data:`signal.SIGINT`, :data:`signal.SIGTERM` and :data:`signal.SIGABRT` on non Windows platforms. Caution: Not every :class:`asyncio.AbstractEventLoop` implements :meth:`asyncio.loop.add_signal_handler`. Most notably, the standard event loop on Windows, :class:`asyncio.ProactorEventLoop`, does not implement this method. If this method is not available, stop signals can not be set. Raises: :exc:`RuntimeError`: If the Application does not have an :class:`telegram.ext.Updater`. zLApplication.run_polling is only available if the application has an Updater.z20.6z|Setting timeouts via `Application.run_polling` is deprecated. Please use `ApplicationBuilder.get_updates_*_timeout` instead.r~rrrENcD>TRTRUSS95 gN)errorr)r process_error)rrJs rLerror_callback/Application.run_polling..error_callbackas!   T//c$/G HrN) rrrrrrrrr rupdater_coroutiner r )rwrrr r2r!_Application__run start_polling) rJrrrrrrrrr r r rs ` rL run_pollingApplication.run_pollings\||^   G\O^_L_ ` %U    I  I$ Izz"ll88+"3)+ /) /%9-9 "%  rNr(listenporturl_pathcertkey webhook_url ip_addressmax_connections secret_tokenunixr3cUR(d [S5eURURRUUUUUUU UUU U UUS9 U U S9$)a Convenience method that takes care of initializing and starting the app, listening for updates from Telegram using :meth:`telegram.ext.Updater.start_webhook` and a graceful shutdown of the app on exit. |app_run_shutdown| :paramref:`stop_signals`. If :paramref:`cert` and :paramref:`key` are not provided, the webhook will be started directly on ``http://listen:port/url_path``, so SSL can be handled by another application. Else, the webhook will be started on ``https://listen:port/url_path``. Also calls :meth:`telegram.Bot.set_webhook` as required. The order of execution by :meth:`run_webhook` is roughly as follows: - :meth:`initialize` - :meth:`post_init` - :meth:`telegram.ext.Updater.start_webhook` - :meth:`start` - Run the application until the users stops it - :meth:`telegram.ext.Updater.stop` - :meth:`stop` - :meth:`post_stop` - :meth:`shutdown` - :meth:`post_shutdown` Important: If you want to use this method, you must install PTB with the optional requirement ``webhooks``, i.e. .. code-block:: bash pip install "python-telegram-bot[webhooks]" .. include:: inclusions/application_run_tip.rst .. seealso:: :wiki:`Webhooks` Args: listen (:obj:`str`, optional): IP-Address to listen on. Defaults to `127.0.0.1 `_. port (:obj:`int`, optional): Port the bot should be listening on. Must be one of :attr:`telegram.constants.SUPPORTED_WEBHOOK_PORTS` unless the bot is running behind a proxy. Defaults to ``80``. url_path (:obj:`str`, optional): Path inside url. Defaults to `` '' `` cert (:class:`pathlib.Path` | :obj:`str`, optional): Path to the SSL certificate file. key (:class:`pathlib.Path` | :obj:`str`, optional): Path to the SSL key file. bootstrap_retries (:obj:`int`, optional): Whether the bootstrapping phase of the :class:`telegram.ext.Updater` will retry on failures on the Telegram server. * < 0 - retry indefinitely * 0 - no retries (default) * > 0 - retry up to X times webhook_url (:obj:`str`, optional): Explicitly specify the webhook url. Useful behind NAT, reverse proxy, etc. Default is derived from :paramref:`listen`, :paramref:`port`, :paramref:`url_path`, :paramref:`cert`, and :paramref:`key`. allowed_updates (Sequence[:obj:`str`], optional): Passed to :meth:`telegram.Bot.set_webhook`. .. versionchanged:: 21.9 Accepts any :class:`collections.abc.Sequence` as input instead of just a list drop_pending_updates (:obj:`bool`, optional): Whether to clean any pending updates on Telegram servers before actually starting to poll. Default is :obj:`False`. ip_address (:obj:`str`, optional): Passed to :meth:`telegram.Bot.set_webhook`. max_connections (:obj:`int`, optional): Passed to :meth:`telegram.Bot.set_webhook`. Defaults to ``40``. close_loop (:obj:`bool`, optional): If :obj:`True`, the current event loop will be closed upon shutdown. Defaults to :obj:`True`. .. seealso:: :meth:`asyncio.loop.close` stop_signals (Sequence[:obj:`int`] | :obj:`None`, optional): Signals that will shut down the app. Pass :obj:`None` to not use stop signals. Defaults to :data:`signal.SIGINT`, :data:`signal.SIGTERM` and :data:`signal.SIGABRT`. Caution: Not every :class:`asyncio.AbstractEventLoop` implements :meth:`asyncio.loop.add_signal_handler`. Most notably, the standard event loop on Windows, :class:`asyncio.ProactorEventLoop`, does not implement this method. If this method is not available, stop signals can not be set. secret_token (:obj:`str`, optional): Secret token to ensure webhook requests originate from Telegram. See :paramref:`telegram.Bot.set_webhook.secret_token` for more details. When added, the web server started by this call will expect the token to be set in the ``X-Telegram-Bot-Api-Secret-Token`` header of an incoming request and will raise a :class:`http.HTTPStatus.FORBIDDEN ` error if either the header isn't set or it is set to a wrong token. .. versionadded:: 20.0 unix (:class:`pathlib.Path` | :obj:`str` | :class:`socket.socket`, optional): Can be either: * the path to the unix socket file as :class:`pathlib.Path` or :obj:`str`. This will be passed to `tornado.netutil.bind_unix_socket `_ to create the socket. If the Path does not exist, the file will be created. * or the socket itself. This option allows you to e.g. restrict the permissions of the socket for improved security. Note that you need to pass the correct family, type and socket options yourself. Caution: This parameter is a replacement for the default TCP bind. Therefore, it is mutually exclusive with :paramref:`listen` and :paramref:`port`. When using this param, you must also run a reverse proxy to the unix socket and set the appropriate :paramref:`webhook_url`. .. versionadded:: 20.8 .. versionchanged:: 21.1 Added support to pass a socket instance itself. zLApplication.run_webhook is only available if the application has an Updater.) rrrrr rr r!rr"r#r$r%r)rwrr start_webhook)rJrrrrr rr!rr r"r#r r r$r%s rL run_webhookApplication.run_webhookuszH||^ zz"ll88!"3%9' /% /)9"%#  rNrc [R"5nU[LaH[R"5S:wa/[ R [ R[ R4n[U[5(d-U=(d /HnURXPR5 M URUR!55 UR"(a URUR#U55 UR$R'5(Ga5[(R+S5 UR-5 UR.R0(a)URUR.R355 UR0(aPURUR355 UR4(a URUR5U55 URUR755 UR8(a URUR9U55 U(aUR-5 ggURU5 URUR;55 UR=5 UR-5 UR.R0(a)URUR.R355 UR0(aPURUR355 UR4(a URUR5U55 URUR755 UR8(a URUR9U55 U(aUR-5 gg![an[SUSU<S3SS9 SnAGN'SnAff=f!U(aUR-5 ff=f![>[@4a [(RCS5 GNf=f!U(aUR-5 ff=f!UR-5 UR.R0(a)URUR.R355 UR0(aPURUR355 UR4(a URUR5U55 URUR755 UR8(a URUR9U55 U(aUR-5 ff!U(aUR-5 ff=f=f) NWindowsz3Could not add signal handlers for the stop signals z due to exception `z_`. If your event loop does not implement `add_signal_handler`, please pass `stop_signals=None`.r?rzCApplication received stop signal via `stop_running`. Shutting down.z0Application received stop signal. Shutting down.)"rget_event_looprplatformsystemsignalSIGINTSIGTERMSIGABRTrradd_signal_handlerrNotImplementedErrorr run_until_completerrsris_setrrcloserwrrrurrtr run_foreverKeyboardInterruptrr)rJrr r loopsigrs rL__runApplication.__runs%%' < 'HOO,=,J"MM6>>6>>JL lL99'-2-C++C1H1HI. !  # #DOO$5 6~~''t(<=))0022 bc  # # % !<<''++DLL,=,=,?@<<++DIIK8~~//t0DE'' 8%%++D,>,>t,DEJJL/  # #$5 6  # #DJJL 1      # # % !<<''++DLL,=,=,?@<<++DIIK8~~//t0DE'' 8%%++D,>,>t,DEJJLM#  El^T!W%44    LJJL)":. N MML M N(JJL  # # % !<<''++DLL,=,=,?@<<++DIIK8~~//t0DE'' 8%%++D,>,>t,DEJJL:JJLsx(AN/+BO6C5OAO6!C5P"/ O9OOO36%PP?PP?"P<?U<C5UU<U99U<r coroutinerrzasyncio.Task[RT]c"URXUS9$)aThin wrapper around :func:`asyncio.create_task` that handles exceptions raised by the :paramref:`coroutine` with :meth:`process_error`. Note: * If :paramref:`coroutine` raises an exception, it will be set on the task created by this method even though it's handled by :meth:`process_error`. * If the application is currently running, tasks created by this method will be awaited with :meth:`stop`. .. seealso:: :wiki:`Concurrency` Args: coroutine (:term:`awaitable`): The awaitable to run as task. .. versionchanged:: 20.2 Accepts :class:`asyncio.Future` and generator-based coroutine functions. .. deprecated:: 20.4 Since Python 3.12, generator-based coroutine functions are no longer accepted. update (:obj:`object`, optional): If set, will be passed to :meth:`process_error` as additional information for the error handlers. Moreover, the corresponding :attr:`chat_data` and :attr:`user_data` entries will be updated in the next run of :meth:`update_persistence` after the :paramref:`coroutine` is finished. Keyword Args: name (:obj:`str`, optional): The name of the task. .. versionadded:: 20.4 Returns: :class:`asyncio.Task`: The created task. )r>rr)_Application__create_task)rJr>rrs rLrApplication.create_taskMsL!!I4!PPrNis_error_handlerc[R"URXUS9US9nUR(a8URR U5 UR UR5 U$[SSS9 U$)N)r>rrBrzpTasks created via `Application.create_task` while the application is not running won't be automatically awaited!r?r) rr"_Application__create_task_callbackrraddadd_done_callback'_Application__create_task_done_callbackr )rJr>rrBrtasks rL __create_taskApplication.__create_taskus")!4!4  ' '#EU (  "  <<  $ $ ( ( .  " "4#C#C D :   rNrHcURRU5 [R"[R [R 5 UR5 SSS5 g!,(df  g=frG)rdiscard contextlibsuppressrCancelledErrorInvalidStateError exception)rJrHs rL__create_task_done_callback'Application.__create_task_done_callbacksK   ((. !7!79R9R S NN T S Ss A)) A7c# [RS:aW[U[5(aB[ [ SS55 [ R"U5IShvN URUS9 $UIShvN URUS9 $N,N![a[n[U[5(a [ SSS9 eU(a[RSUS 9 eURX$US 9IShvN eSnAff=f!URUS9 f=f7f) Nr>z20.4zZGenerator-based coroutines are deprecated in create_task and will not work in Python 3.12+rzKApplicationHandlerStop is not supported with handlers running non-blocking.rdAn error was raised and an uncaught error was raised while handling the error with an error_handler.r)rrr>)sys version_inforrr r2rr_mark_for_persistence_updaterrBrrQr)rJr>rrBrQs rL__create_task_callback"Application.__create_task_callbacks & =')jI.N.N)0%00;;8  - -V - <3#?2  - -V - <9<# )%;<<a ( "!!@&" ((S\(]]] - 0  - -V - nUGH2nURU5nUbUSLaMU(d>URR R X5nUR5IShvN URXXb5nUR(arUR[La[UR[ 5(alURR"(aQURR"R(d,UR%UUSURR&SU3S9 O SnUIShvN GM< GMA U(aUR/US 9 gg![a!n[RSUUS9 SnA gSnAff=fGN#NX![(a [R+S 5  Mn[aEnUR-XS 9IShvN (a[R+S 5 SnA MSnAGMSnAff=f7f) a,Processes a single update and marks the update to be updated by the persistence later. Exceptions raised by handler callbacks will be processed by :meth:`process_error`. .. seealso:: :wiki:`Concurrency` .. versionchanged:: 20.0 Persistence is now updated in an interval set by :attr:`telegram.ext.BasePersistence.update_interval`. Args: update (:class:`telegram.Update` | :obj:`object` | :class:`telegram.error.TelegramError`): The update to process. Raises: :exc:`RuntimeError`: If the application was not initialized. NFzQError while building CallbackContext for update %s. Update will not be processed.rrz:process_update_non_blocking:r^Tz7Stopping further handlers due to ApplicationHandlerStop)rrz'Error handler stopped further handlers.rU)rrqr check_updaterocontext from_updaterrr refresh_data handle_updateblockrrrlr$defaultsrrrBrrrZ) rJrrp any_blockingrqrcheckrr>s rLrkApplication.process_updates$ !  ,,.H2 'G#008E} " #&*&8&8&@&@&L&LV&ZG&22444+2+@+@u+^I"== 5&txx88 HH-- $ 1 1 7 7((%#)".txx{{m<$$+9!. )(, 'M (/j   - -V - < W ) ##,,%D!'), -# #5&(*  WX ++6+EEEMM"KLF s3H3(F?%F F?F:C F?$F=%F?*H3-F?/H3 F7F2+F?0H32F77F?=F??H0H3" H0+H+=H>H+H3+H00H3groupcSSKJn [U[5(d[ S[R 35e[U[ 5(d [ S5e[X5(aUR(aUR(a|UR(d[SURS35eUR(aAURURU5SURRS3S 9 [!S S S 9 X R";a@/UR"U'[%['UR"R)555UlUR"UR+U5 g )aRegister a handler. TL;DR: Order and priority counts. 0 or 1 handlers per group will be used. End handling of update with :class:`telegram.ext.ApplicationHandlerStop`. A handler must be an instance of a subclass of :class:`telegram.ext.BaseHandler`. All handlers are organized in groups with a numeric value. The default group is 0. All groups will be evaluated for handling an update, but only 0 or 1 handler per group will be used. If :class:`telegram.ext.ApplicationHandlerStop` is raised from one of the handlers, no further handlers (regardless of the group) will be called. The priority/order of handlers is determined as follows: * Priority of the group (lower group number == higher priority) * The first handler in a group which can handle an update (see :attr:`telegram.ext.BaseHandler.check_update`) will be used. Other handlers from the group will not be used. The order in which handlers were added to the group defines the priority. Warning: Adding persistent :class:`telegram.ext.ConversationHandler` after the application has been initialized is discouraged. This is because the persisted conversation states need to be loaded into memory while the application is already processing updates, which might lead to race conditions and undesired behavior. In particular, current conversation states may be overridden by the loaded data. Args: handler (:class:`telegram.ext.BaseHandler`): A BaseHandler instance. group (:obj:`int`, optional): The group identifier. Default is ``0``. rrzhandler is not an instance of zgroup is not intzConversationHandler z8 can not be persistent if application has no persistencerz,:add_handler:conversation_handler_after_initrzA persistent `ConversationHandler` was passed to `add_handler`, after `Application.initialize` was called. This is discouraged.See the docs of `Application.add_handler` for details.r~rN)rr5rr%rrOintrrrrrrerrrlrr rqdictsorteditemsappend)rJrryr5s rL add_handlerApplication.add_handlerAs4F S';//<[=Q=Q?DM e##G,rNrqc[U[5(a [U[5(d [S5e[U[5(aXUR 5HCup4[U[ 5(d[SUS35eUHnUR XS5 M ME g[U[ 5(a0UH)nUR U[R"U55 M+ g[S5e)aRegisters multiple handlers at once. The order of the handlers in the passed sequence(s) matters. See :meth:`add_handler` for details. .. versionadded:: 20.0 Args: handlers (Sequence[:class:`telegram.ext.BaseHandler`] | dict[int, Sequence[:class:`telegram.ext.BaseHandler`]]): Specify a sequence of handlers *or* a dictionary where the keys are groups and values are handlers. .. versionchanged:: 21.7 Accepts any :class:`collections.abc.Sequence` as input instead of just a list or tuple. group (:obj:`int`, optional): Specify which group the sequence of :paramref:`handlers` should be added to. Defaults to ``0``. Example:: app.add_handlers(handlers={ -1: [MessageHandler(...)], 1: [CallbackQueryHandler(...), CommandHandler(...)] } Raises: :exc:`TypeError`: If the combination of arguments is invalid. zBThe `group` argument can only be used with a sequence of handlers.zHandlers for group z must be a sequence of handlers.zThe `handlers` argument must be a sequence of handlers or a dictionary where the keys are groups and values are sequences of handlers.N)rr|rrr~rr get_value)rJrqry handler_group grp_handlersrs rL add_handlersApplication.add_handlerssH h % %j .M.M`a a h % %/7~~/?+ !,99#-m_<\] ,G$$W< , 0@( + +#  ,*@*@*GH$] rNcXRU;aAURURU5 URU(dURU ggg)zRemove a handler from the specified group. Args: handler (:class:`telegram.ext.BaseHandler`): A :class:`telegram.ext.BaseHandler` instance. group (:obj:`object`, optional): The group identifier. Default is ``0``. N)rqremove)rJrrys rLremove_handlerApplication.remove_handlersL mmE* * MM% ' ' 0=='MM%(( +rNchat_idcrURRUS5 URRU5 g)aQDrops the corresponding entry from the :attr:`chat_data`. Will also be deleted from the persistence on the next run of :meth:`update_persistence`, if applicable. Warning: When using :attr:`concurrent_updates` or the :attr:`job_queue`, :meth:`process_update` or :meth:`telegram.ext.Job.run` may re-create this entry due to the asynchronous nature of these features. Please make sure that your program can avoid or handle such situations. .. versionadded:: 20.0 Args: chat_id (:obj:`int`): The chat id to delete. The entry will be deleted even if it is not empty. N)rapoprbrE)rJrs rLdrop_chat_dataApplication.drop_chat_data, GT* 3377@rNuser_idcrURRUS5 URRU5 g)aQDrops the corresponding entry from the :attr:`user_data`. Will also be deleted from the persistence on the next run of :meth:`update_persistence`, if applicable. Warning: When using :attr:`concurrent_updates` or the :attr:`job_queue`, :meth:`process_update` or :meth:`telegram.ext.Job.run` may re-create this entry due to the asynchronous nature of these features. Please make sure that your program can avoid or handle such situations. .. versionadded:: 20.0 Args: user_id (:obj:`int`): The user id to delete. The entry will be deleted even if it is not empty. N)rirrjrE)rJrs rLdrop_user_dataApplication.drop_user_datarrNmessager4 old_chat_id new_chat_idcvU(aU(dU(a [S5e[XU45(d [S5eU(axURcURc [S5eUR=(d URR nUR=(d URR nO5[ U[5(a[ U[5(d [S5eURUURU'URU5 URRU5 g)a0Moves the contents of :attr:`chat_data` at key :paramref:`old_chat_id` to the key :paramref:`new_chat_id`. Also marks the entries to be updated accordingly in the next run of :meth:`update_persistence`. Warning: * Any data stored in :attr:`chat_data` at key :paramref:`new_chat_id` will be overridden * The key :paramref:`old_chat_id` of :attr:`chat_data` will be deleted * This does not update the :attr:`~telegram.ext.Job.chat_id` attribute of any scheduled :class:`telegram.ext.Job`. When using :attr:`concurrent_updates` or the :attr:`job_queue`, :meth:`process_update` or :meth:`telegram.ext.Job.run` may re-create the old entry due to the asynchronous nature of these features. Please make sure that your program can avoid or handle such situations. .. seealso:: :wiki:`Storing Bot, User and Chat Related Data ` Args: message (:class:`telegram.Message`, optional): A message with either :attr:`~telegram.Message.migrate_from_chat_id` or :attr:`~telegram.Message.migrate_to_chat_id`. Mutually exclusive with passing :paramref:`old_chat_id` and :paramref:`new_chat_id`. .. seealso:: :attr:`telegram.ext.filters.StatusUpdate.MIGRATE` old_chat_id (:obj:`int`, optional): The old chat ID. Mutually exclusive with passing :paramref:`message` new_chat_id (:obj:`int`, optional): The new chat ID. Mutually exclusive with passing :paramref:`message` Raises: ValueError: Raised if the input is invalid. z/Message and chat_id pair are mutually exclusivez&chat_id pair or message must be passedNzvInvalid message instance. The message must have either `Message.migrate_from_chat_id` or `Message.migrate_to_chat_id`.z,old_chat_id and new_chat_id must be integers) ranymigrate_from_chat_idmigrate_to_chat_idchatrrr{rarrcrE)rJrrrs rLmigrate_chat_dataApplication.migrate_chat_datasV  {NO OG+677EF F ++38R8R8Z V "66I',,//K!44G K[#..:k33O3OKL L'+{'C $ K( 3377 DrN)rjobrr9c[U[5(aUR(a/URR URR 5 UR (a/URR UR R 5 U(anUR(a%URR UR5 UR(a&URR UR5 gggrG) rreffective_chatrcrEreffective_userrkrr)rJrrs rLrZ(Application._mark_for_persistence_update6s ff % %$$;;??@U@U@X@XY$$;;??@U@U@X@XY {{;;?? L{{;;?? L rNchat_idsuser_idscRU(aL[U[5(aURRU5 OURR U5 U(aM[U[5(aUR RU5 gUR R U5 gg)aMark entries of :attr:`chat_data` and :attr:`user_data` to be updated on the next run of :meth:`update_persistence`. Tip: Use this method sparingly. If you have to use this method, it likely means that you access and modify ``context.application.chat/user_data[some_id]`` within a callback. Note that for data which should be available globally in all handler callbacks independent of the chat/user, it is recommended to use :attr:`bot_data` instead. .. versionadded:: 20.3 Args: chat_ids (:obj:`int` | Collection[:obj:`int`], optional): Chat IDs to mark. user_ids (:obj:`int` | Collection[:obj:`int`], optional): User IDs to mark. N)rr{rcrErrk)rJrrs rL mark_data_for_update_persistence,Application.mark_data_for_update_persistenceEsy& (C((;;??I;;BB8L (C((;;??I;;BB8L rNc# URR5(d]UR(dg[R"URR 5URR S9IShvN ggN![Ra Of=fUR5IShvN URR5(dMg7f)N)r) rr6rrrwait_forrupdate_interval TimeoutErrorrrs rLr Application._persistence_updatercs1188::## &&3388: ,,<<;''  ))+ + +%1188::sM2CAB9B:B>CBBCBC/B20$CCc# URIShvN UR5IShvN SSS5IShvN gN-NN !,IShvN (df  g=f7f)aUpdates :attr:`user_data`, :attr:`chat_data`, :attr:`bot_data` in :attr:`persistence` along with :attr:`~telegram.ext.ExtBot.callback_data_cache` and the conversation states of any persistent :class:`~telegram.ext.ConversationHandler` registered for this application. For :attr:`user_data` and :attr:`chat_data`, only those entries are updated which either were used or have been manually marked via :meth:`mark_data_for_update_persistence` since the last run of this method. Tip: This method will be called in regular intervals by the application. There is usually no need to call it manually. Note: Any data is deep copied with :func:`copy.deepcopy` before handing it over to the persistence in order to avoid race conditions, so all persisted data must be copyable. .. seealso:: :attr:`telegram.ext.BasePersistence.update_interval`, :meth:`mark_data_for_update_persistence` N)r _Application__update_persistencers rLrApplication.update_persistenceysA(111++- - -211 -2111sQA!AA!AAA A!AA!AA!A A  AA!c ^# TR(dg[RS5 [5nTRRR (ahTR RbQURTRR[TR RR555 TRRR(a=URTRR[TR555 TRRR(aTRn[5TlTR n[5TlX#-nUHDnURTRR#U[TRU555 MF UH-nURTRR%U55 M/ TRRR&(aTR(n[5TlTR*n[5TlX#-nUHDnURTRR-U[TR&U555 MF UH-nURTRR/U55 M/ SSKJn [4R6R9STR:R=555Hunup[?X5(aU RA5(dgTRB(a[RS5 O[RES5 U RFn TR:URIU5 OU RK5n OU n U [LRNLaSOU n URTRRQXxU S95 M [RRT"USS 06IShvN n [RS 5 [RRT"U4S jU 56IShvN gN?N7f) Nz.Starting next run of updating the persistence.r) PendingStatec3# UH5up[[R"U5UR55v M7 g7frG)ziprrepeatpop_accessed_write_items).0r states_dicts rL 3Application.__update_persistence..s9D %U!    & (L(L(N O O%Us=?zA ConversationHandlers state was not yet resolved. Updating the persistence with the current state. Will check again on next run of Application.update_persistence.zcA ConversationHandlers state was not yet resolved. Updating the persistence with the current state.)rr  new_staterTzFinished updating persistence.c3r># UH,n[U[5(dMTRUSS9v M. g7fr)rrr)rrrJs rLrrs4%Ffi0>"""=%s77)+rrrrrrrrlrrEupdate_callback_datar persistence_datarmupdate_bot_datarnrcrbupdate_chat_datarrxrkrjupdate_user_datarrrrrrrdr~rrrwarning old_statemark_as_accessedrr(DELETEDupdate_conversationrr) rJ coroutines update_ids delete_idsrrrrr rreffective_new_stateresultss ` rL__update_persistence Application.__update_persistences~  FG%(U     & & 4 4 HH ( ( 4 NN  5544EE     & & / / NN4++;;HT]]>wGH&    & & 0 0DDJ:=%D 7DDJ:=%D 7  $J%$$55gxW^H_?`a&&t//>>wGH& L&/oo&C&CD %)%M%M%S%S%UD ' "D"3)22 !~~''|| >  B'00F<` .. seealso:: :wiki:`Exceptions, Warnings and Logging ` Args: callback (:term:`coroutine function`): The callback function for this error handler. Will be called when an error is raised. Callback signature:: async def callback(update: Optional[object], context: CallbackContext) The error that happened will be present in :attr:`telegram.ext.CallbackContext.error`. block (:obj:`bool`, optional): Determines whether the return value of the callback should be awaited before processing the next error handler in :meth:`process_error`. Defaults to :obj:`True`. zAThe callback is already registered as an error handler. Ignoring.N)rprr)rJrrts rLadd_error_handlerApplication.add_error_handlers.: ** * OO_ ` (-H%rNc<URRUS5 g)zjRemoves an error handler. Args: callback (:term:`coroutine function`): The error handler to remove. N)rpr)rJrs rLremove_error_handler Application.remove_error_handler s $/rNrzJob[CCT]c $# UR(aURR5HunnURRR UUUUUS9nU(ahU[La[UR[5(arURR(aWURRR(d2URU"X5USSURRS3S 9 MU"X5IShvN M g[ R#S US9 g![ a n[ RSUUS9 SnA gSnAff=fNK![ a  g[ a n[ R#S US9 SnAGMZSnAff=f7f) aProcesses an error by passing it to all error handlers registered with :meth:`add_error_handler`. If one of the error handlers raises :class:`telegram.ext.ApplicationHandlerStop`, the error will not be handled by other error handlers. Raising :class:`telegram.ext.ApplicationHandlerStop` also stops processing of the update when this method is called by :meth:`process_update`, i.e. no further handlers (even in other groups) will handle the update. All other exceptions raised by an error handler will just be logged. .. versionchanged:: 20.0 * ``dispatch_error`` was renamed to :meth:`process_error`. * Exceptions raised by error handlers are now properly logged. * :class:`telegram.ext.ApplicationHandlerStop` is no longer reraised but converted into the return value. Args: update (:obj:`object` | :class:`telegram.Update`): The update that caused the error. error (:obj:`Exception`): The error that was raised. job (:class:`telegram.ext.Job`, optional): The job that caused the error. .. versionadded:: 20.0 coroutine (:term:`coroutine function`, optional): The coroutine that caused the error. Returns: :obj:`bool`: :obj:`True`, if one of the error handlers raised :class:`telegram.ext.ApplicationHandlerStop`. :obj:`False`, otherwise. )rr applicationrr>ziError while building CallbackContext for exception %s. Exception will not be processed by error handlers.rNFTrz:process_error:non_blocking)rrBrrWz4No error handlers are registered, logging exception.)rpr~rorp from_errorrrrrrrlr$rurtr@rrBrQ) rJrrrr>rrtrprs rLrApplication.process_error)sD   $$**,!"0088CC%#$("+ DG$\)"488V44)) HH--33&& 1%)-+DHHKK=8ST ' &v777E-VP[`aK! !$$Q!$ %! !281$#$))H%(*sw2F'D(B!F> E E EF( E2E F EFE F !F$ F -FFF  F)r[r`r\r]r^r_rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrx)rEr8)rEr7)rEN)rr5rEN)TrG)NFN)NF)NNN)NN)crOrPrQrRrSrXrYrTr*rr&r-r"r/r,r)r#r+rrrrIr;rtyperr rstrrpropertyboolrr{rr{r| staticmethodrrrrrrrrrrrrfloatrrrrrrrr r(r _CoroTyper.rUrr@rTaskrGrDrfrrarkr:r%r _DEFAULT_0r|rrrrrrrZrrrrrrr1rrr_ErrorCoroTyperrVrzrNrLr<r<ts:st   w &I# JMRO54O5O5. O5 '" O5  O50O5ob"bj9:O5$CRO4O5 <=ycSW?XX Y O5 <=ycSW?XX Y O5  <=ycSW?XX Y !O5bxH" 4 ./ -( '    B# B =C = = 8O4  &&$$ )+V %"N:3j@4D#N #!#(4)5+7(437/30<O O O  O uo O   O "%O uoO "(3-0O 'tnO O x}-O  O f)&+/*.!"%)37/3$(!0<&*59![ s [ Sk[  [ uS$Y'( [ eCI& ' [ [ c][ "(3-0[ 'tn[ SM[ [ [ x}-[ sm[ uS$012![ " #[ B 9!$9!x}-9! 9!  9!|$(&Q # &QR=&Q &Q sm &Q  &QV$(!&" R=   sm   < $(!& ,=R=,= ,= ,= ,=\<, 2*V** P=6P=dP=dMZ?-;sC}#=?-c?-^b?-N0: 9 [c3/ 0 h{3S=9:: ; = 9 S,s++, 9 9xAN)"3S=1):=) ) AcAdA&AcAdA*(,%)%) @E)$@Ec]@Ec] @E  @EH-1 M!&) M7? M  M SWM S*M=Ec#h=OM M<,,..k `+!.!&#t"34!.d|!.  !.F0_VS$=N-O0TX0%)26 T TTj ! T N2./ T  TTrN)jrSrrMrrr-r/rX collectionsrcollections.abcrrrrrcopyr pathlibr typesr r typingr rrrrrrrtelegram._updatertelegram._utils.defaultvaluerrrrrtelegram._utils.loggingrtelegram._utils.reprrtelegram._utils.typesrrrtelegram._utils.warningsr telegram.errorr!telegram.ext._basepersistencer"telegram.ext._contexttypesr#telegram.ext._extbotr$"telegram.ext._handlers.basehandlerr%telegram.ext._updaterr&telegram.ext._utils.stackr' telegram.ext._utils.trackingdictr(telegram.ext._utils.typesr)r*r+r,r-r.r/r0r1telegram.warningsr2r3telegramr4rr5r6 telegram.ext._applicationbuilderr7!telegram.ext._baseupdateprocessorr8telegram.ext._jobqueuer9r:r{__annotations__r;rUrrrYrrrOrrrBAbstractAsyncContextManagerr<rzrNrLrsC&2 #NN1\\\#/?77)(93':)39ccc3 :GE* s :] 3x !_ w" Ii 8$ BCYr]RSI)B-( X -Y->I BRR #$**=9IrN