՟f{G UdZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl m Z ddlmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%ddl&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/dd l0m1Z1dd l2m3Z3m4Z4m5Z5dd l6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQddlRmSZSer&ddlTmTZTddlUmVZVddlWmXZXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_dZ`eaebd<e$dd !ZcedZee-dZfejd"k\reeNZhne%ed#deNfeeNfZheeheNZie/ejZkGd$d%elZmGd&d eeJeKeOeLeIeMfed Zny)'z+This module contains the Application class.N) defaultdict)deepcopy)Path)MappingProxyType TracebackType) TYPE_CHECKINGAnyAsyncContextManager AwaitableCallable Coroutine DefaultDictDict GeneratorGenericListMappingNoReturnOptionalSequenceSetTupleTypeTypeVarUnion)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]c8eZdZdZdZddeeddffd ZxZS)ApplicationHandlerStopa 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. )stateNrJreturnc0t|||_yN)super__init__rJ)selfrJ __class__s T/var/www/cvtools/html/venv/lib/python3.12/site-packages/telegram/ext/_application.pyrOzApplicationHandlerStop.__init__s ', rM) __name__ __module__ __qualname____doc__ __slots__robjectrO __classcell__)rQs@rRrIrIhs,.I-hv.-$--rSrIc#eZdZdZej dk\rdndZdddedd d ee d e d d dee e e efdeee e efdeedgeeedffdeedgeeedffdeedgeeedfffdZdedefdZdeeedeedeeddfdZdefdZedefdZede fdZ!ededfdZ"ed{d Z#e$de%fd!Z&e$d|d"Z'd}d#Z(d}d$Z)d~d&Z*d}d'Z+d}d(Z,d}d)Z-d}d*Z.d}d+Z/d,d-d.e0e0e0e0ddd/e0f d0e1d1e d2e d3e2e1d4e2e1d5e2e1d6e2e1d7ee3ed8eed9ed:e2e4e ddfd;Z5e6e7dd/e0ddfd?e8ed@e8e dAedBee9ee:fdCee9ee:fd2e dDeed7ee3ed8eedEeedFe d9ed:e2e4e dGeedHee9ee:dIfddf dJZ; ddKed:e2e4e d9eddfdLZ< dddMdNe=e>dOee?dPeeddQfdRZ@ ddNe=e>dOee?dSedPeeddQf dTZAdUeBjddfdVZD ddNe=e>dOee?dSede>fdWZEd}dXZFd}dYZGdOe?ddfdZZHdOe?ddfd[ZIeJfd%eKeeefd\e ddfd]ZLeMfd^e9e9e3eKeeefeNeKeeeffeOe e9e3eKeeefeNeKeeeffffd\e9e ePe fddfd_ZQeJfd%eKeeefd\e ddfd`ZRdae ddfdbZSdce ddfddZT ddeedfdgee dhee ddfdiZUdddjdOee?dkedlddfdmZV ddneeWe doeeWe ddfdpZXd}dqZYd}drZZd}dsZ[e\fdte]e?edfdue8eddfdvZ^dte]e?edfddfdwZ_ ddOee?dxe`dkedydNeeae>def dzZby)rCaThis 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 )rF )__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__rPz$Application[BT, CCT, UD, CD, BD, JQ]rnrxzasyncio.Queue[object]ry job_queueupdate_processorr?rtrqruNrvrwc Bttjttj j dz s tdd||_||_ ||_ ||_ i|_ i|_ ||_| |_| |_||_|jj%|_t'|jj(|_t'|jj,|_t1|j*|_t1|j.|_d|_|rt5|t6s t9d||_t;|_t;|_t;|_ t;|_!i|_"d|_#d|_$||_%d|_&d|_'tQjR|_*tQjV|_,t;|_-tQjR|_.y)Nz_applicationbuilder.pyzE`Application` instances should be built via the `ApplicationBuilder`. stacklevelz9persistence must be based on telegram.ext.BasePersistenceF)/r.inspect currentframer__file__parentresolver'rnrxrqryrsrrrurvrwrjrorrzrkrprcrrt isinstancer) TypeErrorsetrermrdrlrfrgrirh!_Application__update_fetcher_task%_Application__update_persistence_taskasyncioEvent&_Application__update_persistence_eventLock%_Application__update_persistence_lock_Application__create_task_tasks!_Application__stop_running_marker) rPrnrxryr}r~rtrqrurvrws rRrOzApplication.__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 ExceptionshutdownrPs rR __aenter__zApplication.__aenter__wsG //# # # $ --/ ! !  s.A  A A?AAexc_typeexc_valexc_tbc@K|jd{y7w)z>|async_context_manager| :meth:`shuts down ` the App.N)r)rPrrrs rR __aexit__zApplication.__aexit__smmos c0t||jS)a"Give 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` )rn)r#rnrs rR__repr__zApplication.__repr__s.dAArSc|jS)z}:obj:`bool`: Indicates if this application is running. .. seealso:: :meth:`start`, :meth:`stop` )rirs rRrunningzApplication.runnings}}rSc.|jjS)a: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` )rjmax_concurrent_updatesrs rRconcurrent_updateszApplication.concurrent_updatess%%<<` zqNo `JobQueue` set up. To use `JobQueue`, you must install PTB via `pip install "python-telegram-bot[job-queue]"`.rr)rhr'rs rRr}zApplication.job_queues+ ?? " B  rSc|jS)z:class:`telegram.ext.BaseUpdateProcessor`: The update processor used by this application. .. seealso:: :wiki:`Concurrency` .. versionadded:: 20.4 )rjrs rRr~zApplication.update_processors%%%rSctrM) SystemExitr|rSrR_raise_system_exitzApplication._raise_system_exitsrScddlm}|S)ztConvenience method. Returns a new :class:`telegram.ext.ApplicationBuilder`. .. versionadded:: 20.0 rApplicationBuilder) telegram.extrrs rRbuilderzApplication.builders 4!##rSc2|js tdy)NzBThis Application was not initialized via `Application.initialize`!)rg RuntimeErrorrs rR_check_initializedzApplication._check_initializeds   T !rScK|jrtjdy|jj d{|j j d{|j r"|j j d{|jsd|_y|jd{ddl m }tjj|jjD]B}t!||s|j"s|j$s*|j'|d{Dd|_|j(j+y7%77772w)a<Initializes 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.NTrr<)rg_LOGGERdebugrnrrjryrt_initialize_persistence*telegram.ext._handlers.conversationhandlerr< itertoolschain from_iterablersvaluesr persistentname_add_ch_to_persistencerclear)rPr<handlers rRrzApplication.initializes,    MMD E hh!!###$$//111 <<,,))+ + + $D  **,,, S!44T]]5I5I5KL ;G'#67GE/?AE3 E3 E3*E3>E1?)E3*E3-E3/E31E3rctK|jj|j|d{y7 wrM)rfupdater)rPrs rRrz"Application._add_ch_to_persistences. 007711$7 7 7s *86 8cdK|jr td|jstj dy|j j d{|jj d{|jr"|jj d{|jrdtj d|jd{|jjd{tj dd|_y7777I7)w)aShuts down the Application by shutting down: * :attr:`bot` by calling :meth:`telegram.Bot.shutdown` * :attr:`updater` by calling :meth:`telegram.ext.Updater.shutdown` * :attr:`persistence` by calling :meth:`update_persistence` and :meth:`BasePersistence.flush` * :attr:`update_processor` by calling :meth:`telegram.ext.BaseUpdateProcessor.shutdown` Does *not* call :attr:`post_shutdown` - that is only done by :meth:`run_polling` and :meth:`run_webhook`. .. seealso:: :meth:`initialize` Raises: :exc:`RuntimeError`: If the application is still :attr:`running`. z"This Application is still running!z1This Application is already shut down. Returning.Nz/Updating & flushing persistence before shutdownzUpdated and flushed persistenceF) rrrgrrrnrrjryrtupdate_persistenceflushrs rRrzApplication.shutdowns$ <<CD D  MMM N hh!!!$$--/// <<,,'') ) )    MMK L))+ + +""((* * * MM; <! "/ * , *sZAD0D&!D0;D(<-D0)D**8D0"D,#!D0D."D0(D0*D0,D0.D0c8K|jsy|jjjr;|jj |jj d{|jjj r;|jj |jjd{|jjjr}|jjd{|_ t|j|jjs,td|jjj|jjjr|j j"t|jj%d{}|Ot|t&rt)|dk7r td|j j"j+|yyyy77U77aw)zHThis method basically just loads all the data by awaiting the BP methodsNzbot_data must be of type rz)callback_data must be a tuple of length 2)rt store_datarzrkr get_user_datarprc get_chat_dataro get_bot_datarrq ValueErrorrT callback_datarncallback_data_cacheget_callback_datatuplelenload_persistence_data)rPpersistent_datas rRrz#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-HI /0B0B0K0K0T0T/UV    & & 4 4 HH ( ( 4$($4$4$F$F$HHO*!/59S=QUV=V$%PQQ,,BB#+ 5 5$J#IAIsLA H"H#AH=H>AHHB2H6H7AHHHHcK|jr td|jd|_|jj  |j rWtj|jd|jjd|_ tjd|jr7|jj!d{tjdtj|j#d|jjd |_tj'd y7q#t($r d |_wxYww) aStarts * 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)rrrrirrrtr create_task_persistence_updaterrnidrrrrhstart_update_fetcherrinforrs rRrzApplication.startXs2 <<EF F !  ''--/ 181D1D--/' }4HI2. EFoo++--- 01)0)<)<$$&|DHHKK=-X*D & LL. / . !DM  s2A E! B E E A0E E! E EE!cK|js tdd|_|jj t j d|jr|jjr |jjnr|jjtd{t jd|jj!d{|jd{t jd |j"rNt jd |j"j%d d{t jd t jd t'j(|j*ddid{|j,ri|j.r]t jd|j0j3|j.d{|j0j t j dy#t$r#}t jd|dYd}~]d}~wwxYw777p777qw)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)rrrirrrrrdoneresult BaseExceptioncriticalrxput _STOP_SIGNALrjoinrhstoprgatherrrtrrr)rPexcs rRrzApplication.stops.||AB B  ""((* IJ  % %))..0..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 1sA4I97H:#I94I)56I9+I,,I9?I/AI9I2AI9*I5+AI9I74I9: I&I!I9!I&&I9,I9/I92I95I97I9c|jr#tjjy|jj |j stjdyy)a|This 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_looprrrrgrrrs rR stop_runningzApplication.stop_runningsS2 <<  $ $ & + + -  & & * * ,$$ !%rSg T poll_intervaltimeoutbootstrap_retries read_timeout write_timeoutconnect_timeout pool_timeoutallowed_updatesdrop_pending_updates close_loop stop_signalsc  js td||||ftfdzk7rtt ddddt dd ffd } j jj||||||||| | | | S) aConvenience 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 (List[:obj:`str`], optional): Passed to :meth:`telegram.Bot.get_updates`. 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.rrrrKNcJjj|dyN)errorr)r process_error)rrPs rRerror_callbackz/Application.run_polling..error_callbackns!   T//c$/G HrS) rrrrrrrrrrupdater_coroutinerr)ryrrr'r9r(_Application__run start_polling) rPrrrrrrrrrrrrs ` rR run_pollingzApplication.run_pollingsV||^  -, G\O^_L_ ` %U    I  I$ Izz"ll88+"3)+ /) /%9-9 "%  rSr(listenporturl_pathcertkey webhook_url ip_addressmax_connections secret_tokenunixr:c|js td|j|jj||||||| ||| | || | | S)abConvenience 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 (List[:obj:`str`], optional): Passed to :meth:`telegram.Bot.set_webhook`. 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.) r r r r rrrrrrrrrr)ryrr start_webhook)rPr r r r rrrrrrrrrrrs rR run_webhookzApplication.run_webhookszB||^ zz"ll88!"3%9' /% /)9"%#  rSrc tj}|turFtjdk7r/t j t jt jf} t|ts'|xsgD]}|j||j  |j|j!|j"r |j|j#||j$j'rt(j+d |j- |j.j0r)|j|j.j3|j0rK|j|j3|j4r |j|j5||j|j7|j8r |j|j9||r|j-yy|j||j|j;|j=|j- |j.j0r)|j|j.j3|j0rK|j|j3|j4r |j|j5||j|j7|j8r |j|j9||r|j-yy#t$r}td|d|ddYd}~d}~wwxYw#|r|j-wwxYw#t>t@f$rt(jCdYpwxYw#|r|j-wwxYw#|j- |j.j0r)|j|j.j3|j0rK|j|j3|j4r |j|j5||j|j7|j8r |j|j9||r|j-ww#|r|j-wwxYwxYw) 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`.rFrzCApplication received stop signal via `stop_running`. Shutting down.z0Application received stop signal. Shutting down.)"rget_event_looprplatformsystemsignalSIGINTSIGTERMSIGABRTrr!add_signal_handlerrNotImplementedErrorr'run_until_completerruris_setrrcloseryrrrwrrvr run_foreverKeyboardInterruptrr)rPrrrloopsigrs rR__runzApplication.__runs%%' < 'HOO,=,J"MM6>>6>>JL lL9'-2JC++C1H1HIJ !  # #DOO$5 6~~''t(<=))002 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:JJLsw$7M$A;N')C!NAN'/C!O$ N -NN N$'$O O*OO*O'*T )rrsr check_updaterqcontext from_updaterrr refresh_data handle_updateblockr rrnr+defaultsrrrIrrrC) rPrrU any_blockingrsrcheckrr*s rRrQzApplication.process_updates$ !  ,,.3 H2 '&G#008E} " #&*&8&8&@&@&L&LVUY&ZG&22444+2+@+@uV]+^I"== 5&txx8 HH-- $ 1 1 7 7((%#)".txx{{m<$$+9!. )(, 'M&3 j   - -V - < W ) ##,,%D!'), -# #5&(*  WX ++6+EEEMM"KLF s3H F#&E.=F#FB?DM e##G,rSrsct|trt|ts tdt|trW|j D]C\}}t|t t fstd|d|D]}|j||Eyt|t t fr-|D]'}|j|tj|)ytd)a}Registers 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 (List[:class:`telegram.ext.BaseHandler`] | Dict[int, List[:class:`telegram.ext.BaseHandler`]]): Specify a sequence of handlers *or* a dictionary where the keys are groups and values are handlers. 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 list or tuplezThe `handlers` argument must be a sequence of handlers or a dictionary where the keys are groups and values are sequences of handlers.N) rr`r!rrblistrrd get_value)rPrsr] handler_group grp_handlersrs rR add_handlerszApplication.add_handlerss> h %j .M`a a h %/7~~/? =+ |!,u >#&9-H`$abb+=G$$Wm<=  =4- 0# I  ,*@*@*GH I] rSc||j|vr<|j|j||j|s|j|=yyy)aRemove 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)rsremove)rPrr]s rRremove_handlerzApplication.remove_handlersN dmmE* * MM% ' ' 0=='MM%(( +rSchat_idcr|jj|d|jj|y)aDrops 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)rcpoprdr0)rPrns rRdrop_chat_datazApplication.drop_chat_data, GT* 3377@rSuser_idcr|jj|d|jj|y)aDrops 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)rkrprlr0)rPrss rRdrop_user_datazApplication.drop_user_datarrrSmessager; old_chat_id new_chat_idc|r|s|r tdt|||fs td|rl|j|j td|jxs|jj }|jxs|jj }n+t |trt |ts td|j||j|<|j||jj|y)aMoves 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_rcrqrer0)rPrvrwrxs rRmigrate_chat_datazApplication.migrate_chat_datasV  {NO OG[+67EF F ++38R8R8Z V "66I',,//K!44G K[#.:k33OKL L'+{'C $ K( 3377 DrS)rjobrr@ct|trv|jr/|jj |jj |j r/|jj |j j |rd|jr%|jj |j|jr&|jj |jyyyrM) rreffective_chatrer0reffective_userrmrnrs)rPrrs rRrCz(Application._mark_for_persistence_update9s ff %$$;;??@U@U@X@XY$$;;??@U@U@X@XY {{;;?? L{{;;?? L rSchat_idsuser_idsc*|rGt|tr|jj|n|jj ||rHt|tr|j j|y|j j |yy)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_rer0rrm)rPrrs rR mark_data_for_update_persistencez,Application.mark_data_for_update_persistenceHss& (C(;;??I;;BB8L (C(;;??I;;BB8L rScK|jjs[|jsy tj|jj |jj d{yyy7#tj$rYnwxYw|jd{7|jjsRw)N)r) rr#rtrwait_forrupdate_interval TimeoutErrorrrs rRrz Application._persistence_updaterfs1188:## &&3388: ,,<<;''  ))+ + +%1188:sG(C AA;1A92A;6C 9A;;BC BC 'B*(C cK|j4d{|jd{dddd{y7-77 #1d{7swYyxYww)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 rRrzApplication.update_persistence|sV(11 . .++- - - . . . - . . . .sQAAAAAA AAAAAA A AAc vKjsytjdt}jjj rgj jQ|jjjtj jjjjjr=|jjjtjjjjrj}t_j }t_||z}|D]C}|jjj#|tj|E|D],}|jjj%|.jjj&rj(}t_j*}t_||z}|D]C}|jjj-|tj&|E|D],}|jjj/|.ddlm}t4j6j9dj:j=DD]\}\}} t?| |r| jAsbjBrtjdntjEd| jF} j:|jI|n| jK} n| } | tLjNurdn| } |jjjQ||| tSjT|dd id{} tjd tSjTfd | Dd{y7=7w) Nz.Starting next run of updating the persistence.r) PendingStatec3|K|]4\}}ttj||j6ywrM)ziprrepeatpop_accessed_write_items).0r states_dicts rR z3Application.__update_persistence..s9D !k    & (L(L(N OD s:<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.c3dK|]'}t|trj|d)ywr)rrr)rrrPs rRrz3Application.__update_persistence..s3fi0"""=s-0)+rtrrrrrrnrr0update_callback_datarpersistence_dataroupdate_bot_datarprerdupdate_chat_datarqrzrmrlupdate_user_datarurrrrrrfrbrrrwarning old_statemark_as_accessedrr/DELETEDupdate_conversationrr) rP coroutines update_ids delete_idsrnrsrrrrreffective_new_stateresultss ` rR__update_persistencez Application.__update_persistences  FG%(U     & & 4 4 HH ( ( 4 NN  5544EE     & & / / NN4++;;HT]]>wGH I    & & 0 0DDJ:=%D 7DDJ:=%D 7 * $J% $$55gxW^H_?`a & It//>>wGH I L&/oo&C&CD %)%M%M%S%S%UD ' #  "D"3 )\2 !~~'|| >  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)rrrr)rPrrYs rRadd_error_handlerzApplication.add_error_handlers2: t** * OO_ ` (-H%rSc<|jj|dy)zRemoves an error handler. Args: callback (:term:`coroutine function`): The error handler to remove. N)rrrp)rPrs rRremove_error_handlerz Application.remove_error_handler#s $/rSrzJob[CCT]c K|jr|jjD]\}} |jjj |||||}|rX|turt|jtrk|jjrU|jjjs5|j||||dd|jjd  |||d{yt j#d |y#t $r#}t jd||Yd}~yd}~wwxYw7N#t $rYyt $r"}t j#d |Yd}~Od}~wwxYww) 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)rr-rr@z4No error handlers are registered, logging exception.)rrrbrqrU from_errorrrrr rrnr+rZrYr,rrIr;) rPrrrr*rrYrUrs rRrzApplication.process_error,sD   $$**,- !"0088CC%#$("+ DG$\)"488V4)) HH--33&& 1%)-+DHHKK=8ST ' &vw777K- \P[`aK! !$$Q!$ %! !281$#$))H%(*sw-F*DBF* E6E7E;F ED=7F=EFE E=FE=E82F8E==F)rKr?)rKr>)rKN)rr<rKN)TrM)NFN)NF)NNN)NN)crTrUrVrWrArBrXr1rr-r4r)r6r3r0r*r2r r r rOrBrrrrrstrrpropertyboolrr_rr}r~ staticmethodrrrrrrrrrrrrfloatr&rrrrrr%rrrr _CoroTyper5rYrr,rTaskr2r/rMrrIrQrAr,rd _DEFAULT_0rrr!rjrmrqrur~rCr$rrrrr r8rrr_ErrorCoroTyperr|rSrRrCrCsnst   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(4/3/30<L L L  L uo L   L "%L uoL "$s),L 'tnL L x}-L  L `)&+/*.!"%)/3/3$(!0<&*59!X s X SkX  X uS$Y'( X eCI& ' X X c]X "$s),X 'tnX SMX X X x}-X smX uS$012!X " #X | 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: 2 ${3S=12E+c3PSm:T4UU V eDS#s]!;__`` a c 2 S,s++, 2 2jAN)"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  TrS)orWrr7rrrrrA collectionsrcopyrpathlibrtypesrrtypingrr r r r r rrrrrrrrrrrrrrtelegram._updatertelegram._utils.defaultvaluerrrr r!telegram._utils.loggingr"telegram._utils.reprr#telegram._utils.typesr$r%r&telegram._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.typesr0r1r2r3r4r5r6r7r8telegram.warningsr9r:telegramr;rr<r= telegram.ext._applicationbuilderr>!telegram.ext._baseupdateprocessorr?telegram.ext._jobqueuer@rAr___annotations__rBrYrrrBrrrTrrrIrCr|rSrRrsM&2 #1.$/?77)(93':)39ccc3 :GE* s :] 3x !_ w" Ii 8$ BCYr]RSI)B-( X -Y->y'"c2r2r124G 4VyrS