a 9gn@sddlmZddlZddlmZddlmZmZddlm Z m Z ddl m Z m Z mZmZmZmZmZmZmZddlmZddlmZdd lmZdd lmZdd lmZmZdd l m!Z!dd l"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/m0Z0GdddZ1GdddZ2Gddde Z3GdddZ4GdddZ5eGdddZ6d d d!d"d#d$Z7Gd%d&d&Z8Gd'd(d(Z9Gd)d*d*Z:Gd+d,d,Z;Gd-d.d.ZGd3d4d4Z?e?Z@dS)5) annotationsN) defaultdict) dataclassreplace)Enumauto) AnyClassVarDictListOptionalTupleTypeUnionoverload)Self)loggers) Dispatcher)NextMiddlewareType)CallableObject CallbackType)extract_flags_from_object)Router)SceneException) StateFilter) FSMContext)StateMemoryStorageRecord)TelegramObjectUpdatec@seZdZd!ddddddZd d d d d dZddddZddddZddddZd dddZd dddZ d d d d ddZ d dddZ d S)"HistoryManagerscenes_history rstrint)statedestinysizecCs*||_||_t|jt|j|dd|_dS)N)r')storagekey)_size_staterr)rr*_history_state)selfr&r'r(r/n/var/www/vosh/data/www/fastworkle.ru/webshop-tgbot-v.1.0/venv/lib/python3.9/site-packages/aiogram/fsm/scene.py__init__s zHistoryManager.__init__ Optional[str]Dict[str, Any]None)r&datareturncsr|jIdH}|dg}|||dt||jkrJ||j d}tjd|||jj |dIdHdS)Nhistoryr&r5z Push state=%s data=%s to historyr7) r-get_data setdefaultappendlenr+rscenedebug update_data)r.r&r5 history_datar7r/r/r0push!s zHistoryManager.pushzOptional[MemoryStorageRecord]r6cs|jIdH}|dg}|s$dS|}|d}|d}|sT|jiIdHn|jj|dIdHtjd||t ||dS)Nr7r&r5r9z!Pop state=%s data=%s from historyr8) r-r:r;popset_datar@rr>r?r)r.rAr7recordr&r5r/r/r0rD+s zHistoryManager.popcs6|jIdH}|dg}|s$dStfi|dS)Nr7)r-r:r;rr.rAr7r/r/r0get:s  zHistoryManager.getzList[MemoryStorageRecord]cs*|jIdH}|dg}dd|DS)Nr7cSsg|]}tfi|qSr/r).0itemr/r/r0 Dz&HistoryManager.all..)r-r:r;rHr/r/r0allAs zHistoryManager.allcs"tjd|jiIdHdS)Nz Clear history)rr>r?r-rEr.r/r/r0clearFs zHistoryManager.clearcs6|jIdH}|jIdH}|||IdHdSN)r, get_stater:rBr.r&r5r/r/r0snapshotJszHistoryManager.snapshotcs(|j|IdH|j|IdHdSrQ)r, set_staterErSr/r/r0 _set_stateOszHistoryManager._set_statecsX|IdH}|s(|diIdHdStjd|j|j||j|jIdH|jS)NzRollback to state=%s data=%s)rDrVrr>r?r&r5)r.previous_stater/r/r0rollbackSszHistoryManager.rollbackN)r"r#) __name__ __module__ __qualname__r1rBrDrIrNrPrTrVrXr/r/r/r0r!s r!c@seZdZddddddddd Zd dd d d Zddd ddZddd ddZddddZddd ddZddddZ ddddZ dS)ObserverDecoratorNr$ztuple[CallbackType, ...]zSceneAction | NoneOptional[After]r4)namefiltersactionafterr6cCs||_||_||_||_dSrQ)r^r_r`ra)r.r^r_r`rar/r/r0r1cszObserverDecorator.__init__zType[Scene] | CallbackType)targetr6cCs@t|dd}|s g}t|d||t|j||j|jddS)N__aiogram_handler__r^handlerr_ra)getattrsetattrr<HandlerContainerr^r_ra)r.rbhandlersr/r/r0 _wrap_filteros  zObserverDecorator._wrap_filterrcCsR|jdusJdt|dd}|dur:tt}t|d|t|||j|j<dS)NzScene action is not specified__aiogram_action__)r`rfrdictrgrr^)r.rbr`r/r/r0 _wrap_action~s   zObserverDecorator._wrap_actioncCs8t|r,|jdur ||q4||ntd|S)Nz"Only function or method is allowed)inspect isfunctionr`rjrm TypeErrorr.rbr/r/r0__call__s     zObserverDecorator.__call__ActionContainerrCcCst|j|jtjSrQ)rsr^r_ SceneActionleaverOr/r/r0ruszObserverDecorator.leave Type[Scene]cCst|j|jtj|SrQ)rsr^r_rtenterrqr/r/r0rwszObserverDecorator.entercCst|j|jtjSrQ)rsr^r_rtexitrOr/r/r0rxszObserverDecorator.exitcCst|j|jtjSrQ)rsr^r_rtbackrOr/r/r0ryszObserverDecorator.back)NN) rYrZr[r1rjrmrrrurwrxryr/r/r/r0r\bs   r\c@s$eZdZeZeZeZeZdS)rtN)rYrZr[rrwrurxryr/r/r/r0rtsrtc@s4eZdZddddddddd Zd dd d d ZdS)rsNr$Tuple[CallbackType, ...]rt!Optional[Union[Type[Scene], str]]r4)r^r_r`rbr6cCs||_||_||_||_dSrQ)r^r_r`rb)r.r^r_r`rbr/r/r0r1szActionContainer.__init__ SceneWizardwizardr6cs|jtjkr*|jdur*||jIdHnR|jtjkrF|IdHn6|jtjkrb|IdHn|jtjkr||IdHdSrQ)r`rtrwrbgotorurxryr.r~r/r/r0executes   zActionContainer.execute)N)rYrZr[r1rr/r/r/r0rss rsc@s$eZdZd dddddddd ZdS) rhNr$rrzr]r4)r^rer_rar6cCs||_||_||_||_dSrQrd)r.r^rer_rar/r/r0r1szHandlerContainer.__init__)N)rYrZr[r1r/r/r/r0rhsrhc@sJeZdZUded<ded<ded<dZded <dZded <dZded <dS) SceneConfigr2r&zList[HandlerContainer]riz,Dict[SceneAction, Dict[str, CallableObject]]actionsNzOptional[bool]reset_data_on_enterreset_history_on_entercallback_query_without_state)rYrZr[__annotations__rrrr/r/r/r0rs    rrr4)argskwargsr6csdSrQr/)rrr/r/r0_empty_handlersrc@sPeZdZddddddddZd d d d d d ZddddZddddZdS)SceneHandlerWrapperNrvrr]r4)r>rerar6cCs||_t||_||_dSrQ)r>rrera)r.r>rerar/r/r0r1s zSceneHandlerWrapper.__init__rr)eventrr6c s|d}|d}|d}|jt|jj|||j||dd}|jj||fi|IdH}|jrtdd|jj|jj}| |j IdH|S)Nr&scenes event_update scene_configmanagerr& update_typerr5r~rar/) r>r|__scene_config__ event_typerecallrarsr`rr~) r.rrr&rrr>resultZaction_containerr/r/r0rrs. zSceneHandlerWrapper.__call__rrCcCs|SrQr/rOr/r/r0 __await__ szSceneHandlerWrapper.__await__r$cCs8d|jd|jj}|jr,|d|j7}|d7}|S)NzSceneHandlerWrapper(z, z, after=))r>recallbackra)r.rr/r/r0__str__ s zSceneHandlerWrapper.__str__)N)rYrZr[r1rrrrr/r/r/r0rs  rcseZdZUdZded<dddddZd dd fd d Zed ddddZeddd dddZ ed dd ddZ Z S)Scenea Represents a scene in a conversation flow. A scene is a specific state in a conversation where certain actions can take place. Each scene has a set of filters that determine when it should be triggered, and a set of handlers that define the actions to be executed when the scene is active. .. note:: This class is not meant to be used directly. Instead, it should be subclassed to define custom scenes. zClassVar[SceneConfig]rr|r4r}cCs||_||j_dSrQ)r~r>rr/r/r0r1%szScene.__init__rrr6c sB|dd}|dd}|dd}|dd}tjfi|g}tt}|jD]L}t|tsdqTt|dd} | svqT|dur| j }|dur| j }|durT| j }qTt |D]v\} } t| dd} r|| t| tr|t| jt| j| jdt| dr| jD]\} }|| |qqt||t||||d |_dS) Nr&rrrrrcrark)r&rirrrr)rDsuper__init_subclass__rrl __bases__ issubclassrrfrrrrn getmembersextend isinstancer\r<rhr^rr_rahasattrrkitemsupdaterr)clsrZ state_namerrrrirbaseZparent_scene_configr^valueZscene_handlersr`Zaction_handlers __class__r/r0r,sT          zScene.__init_subclass__rrouterr6cCs|j}t}|jD]F}|j|jjt||j|jdg|j Rdt |ji| |jq|D]*}|j rr|dkrrq^|j| t|jq^dS)z^ Adds the scene to the given router. :param router: :return: rflagscallback_queryN)rsetri observersr^registerrrerar_raddrfilterrr&)rrrZused_observersreZ observer_namer/r/r0 add_to_router_s&   zScene.add_to_routerNr2r^r6cCs>|dur&d|jd|jd|jj}t|d}|||S)zM Returns the scene as a router. :return: new router NzScene '.z ' for state r^)rZr[rr&rr)rr^rr/r/r0 as_router{s  zScene.as_routerrc sddddfdd }|S)z Create an entry point handler for the scene, can be used to simplify the handler that starts the scene. >>> router.message.register(MyScene.as_handler(), Command("start")) r ScenesManagerr4)rrr6cs|jfiIdHdSrQ)rw)rrrrr/r0enter_to_scene_handlersz0Scene.as_handler..enter_to_scene_handlerr/)rrrr/rr0 as_handlers zScene.as_handler)N) rYrZr[__doc__rr1r classmethodrrr __classcell__r/r/rr0rs  3rc@seZdZdZdddddddd d Zd d d ddZd7dd d dddZd d d ddZd d d ddZd d d ddZ dd d dddZ dd dd d!d"Z dd d#d$d%Z dd&d'd(Z edd)d*d+d,Zedd d d-d.d,Zd8dd)d)d-d0d,Zd9d1d dd2d3d4Zd d&d5d6Zd/S):r|as A class that represents a wizard for managing scenes in a Telegram bot. Instance of this class is passed to each scene as a parameter. So, you can use it to transition between scenes, get and set data, etc. .. note:: This class is not meant to be used directly. Instead, it should be used as a parameter in the scene constructor. rrrr$rr3rcCs.||_||_||_||_||_||_d|_dS)a A class that represents a wizard for managing scenes in a Telegram bot. :param scene_config: The configuration of the scene. :param manager: The scene manager. :param state: The FSMContext object for storing the state of the scene. :param update_type: The type of the update event. :param event: The TelegramObject represents the event. :param data: Additional data for the scene. N)rrr&rrr5r>)r.rrr&rrr5r/r/r0r1szSceneWizard.__init__rr4rcsztjd|jj|jjr,|jiIdH|jjrF|jj IdH|j |jjIdH|j t jfi|IdHdS)a Enter method is used to transition into a scene in the SceneWizard class. It sets the state, clears data and history if specified, and triggers entering event of the scene. :param kwargs: Additional keyword arguments. :return: None zEntering scene %rN)rr>r?rr&rrErrr7rPrU _on_actionrtrwr.rr/r/r0rws zSceneWizard.enterTbool) _with_historyrr6csFtjd|jj|r(|jjIdH|jt j fi|IdHdS)a" Leaves the current scene. This method is used to exit a scene and transition to the next scene. :param _with_history: Whether to include history in the snapshot. Defaults to True. :param kwargs: Additional keyword arguments. :return: None zLeaving scene %rN) rr>r?rr&rr7rTrrtru)r.rrr/r/r0rus zSceneWizard.leavecs^tjd|jj|jjIdH|jt j fi|IdH|jj dddi|IdHdS)z Exit the current scene and enter the default scene/state. :param kwargs: Additional keyword arguments. :return: None zExiting scene %rN _check_activeF)N) rr>r?rr&rr7rPrrtrxrwrr/r/r0rxszSceneWizard.exitcs`tjd|jj|jfddi|IdH|jjIdH}|jj |fddi|IdHdS)z This method is used to go back to the previous scene. :param kwargs: Keyword arguments that can be passed to the method. :return: None z$Back to previous scene from scene %srFNr) rr>r?rr&rurr7rXrw)r.rZ new_scener/r/r0ryszSceneWizard.backcs4|jjdusJd|j|jjfi|IdHdS)z This method allows to re-enter the current scene. :param kwargs: Additional keyword arguments to pass to the scene. :return: None NzScene state is not specified)rr&rrr/r/r0retakeszSceneWizard.retakezUnion[Type[Scene], str])r>rr6cs8|jfi|IdH|jj|fddi|IdHdS)a The `goto` method transitions to a new scene. It first calls the `leave` method to perform any necessary cleanup in the current scene, then calls the `enter` event to enter the specified scene. :param scene: The scene to transition to. Can be either a `Scene` instance or a string representing the scene. :param kwargs: Additional keyword arguments to pass to the `enter` method of the scene manager. :return: None NrF)rurrw)r.r>rr/r/r0rs zSceneWizard.gotort)r`rr6cs|jstdtjd|j|jj|jj|i}|sRtjd|j|jjdS|j }||vr|tjd|j||jjdS||j |j|j fii|j |IdHdS)NzScene is not initializedzCall action %r in scene %rzAction %r not found in scene %rFz,Action %r for event %r not found in scene %rT) r>rrr?r^rr&rrIrrrr5)r.r`rZ action_configrr/r/r0rs( ,zSceneWizard._on_action)r5r6cs|jj|dIdHdS)z Sets custom data in the current state. :param data: A dictionary containing the custom data to be set in the current state. :return: None r5N)r&rE)r.r5r/r/r0rE.szSceneWizard.set_datarCcs|jIdHS)z This method returns the data stored in the current state. :return: A dictionary containing the data stored in the scene state. N)r&r:rOr/r/r0r:7szSceneWizard.get_dataz Optional[Any])r*r6csdS)z This method returns the value from key in the data of the current state. :param key: The keyname of the item you want to return the value from. :return: A dictionary containing the data stored in the scene state. Nr/)r.r*r/r/r0 get_value?s zSceneWizard.get_value)r*defaultr6csdS)aC This method returns the value from key in the data of the current state. :param key: The keyname of the item you want to return the value from. :param default: Default value to return, if ``key`` was not found. :return: A dictionary containing the data stored in the scene state. Nr/r.r*rr/r/r0rJs Ncs|j||IdHSrQ)r&rrr/r/r0rVszOptional[Dict[str, Any]])r5rr6cs"|r|||jj|dIdHS)z This method updates the data stored in the current state :param data: Optional dictionary of data to update. :param kwargs: Additional key-value pairs of data to update. :return: Dictionary of updated data rN)rr&r@)r.r5rr/r/r0r@Ys  zSceneWizard.update_datacs|iIdHdS)z9 Clears the data. :return: None N)rErOr/r/r0 clear_datagszSceneWizard.clear_data)T)N)N)rYrZr[rr1rwrurxryrrrrEr:rrr@rr/r/r/r0r|s&       r|c@sleZdZdZdddddddd d Zd d d ddZddddZdd ddddddZdddddZdS)rz The ScenesManager class is responsible for managing scenes in an application. It provides methods for entering and exiting scenes, as well as retrieving the active scene. SceneRegistryr$rrr3r4)registryrrr&r5r6cCs.||_||_||_||_||_t|j|_dSrQ)rrrr&r5r!r7)r.rrrr&r5r/r/r0r1vs zScenesManager.__init__r{r) scene_typer6c s0|j|}|t|j||j|j|j|jddS)Nrr)rrIr|rr&rrr5)r.rr/r/r0 _get_scenes zScenesManager._get_scenezOptional[Scene]rCcs<|jIdH}z||IdHWSty6YdS0dSrQ)r&rRrr)r.r&r/r/r0_get_active_scenes  zScenesManager._get_active_sceneTrr)rrrr6cs|r2|IdH}|dur2|jjfi|IdHz||IdH}Wn.tyt|dur^|jdIdHYn0|jjfi|IdHdS)a Enters the specified scene. :param scene_type: Optional Type[Scene] or str representing the scene type to enter. :param _check_active: Optional bool indicating whether to check if there is an active scene to exit before entering the new scene. Defaults to True. :param kwargs: Additional keyword arguments to pass to the scene's wizard.enter() method. :return: None N)rr~rxrrr&rUrw)r.rrrZ active_scener>r/r/r0rws zScenesManager.enterrcs2|IdH}|sdS|jjfi|IdHdS)z Close method is used to exit the currently active scene in the ScenesManager. :param kwargs: Additional keyword arguments passed to the scene's exit method. :return: None N)rr~rx)r.rr>r/r/r0closeszScenesManager.closeN)T) rYrZr[rr1rrrwrr/r/r/r0rps  rc@seZdZdZd#ddddddZddd d d Zd d dddddZd d dddddZddddddddZdddddZ ddd d!d"Z dS)$rzJ A class that represents a registry for scenes in a Telegram bot. Trrr4)rregister_on_addr6cCs ||_||_i|_||dS)z Initialize a new instance of the SceneRegistry class. :param router: The router instance used for scene registration. :param register_on_add: Whether to register the scenes to the router when they are added. N)rr_scenes_setup_middleware)r.rrr/r/r0r1szSceneRegistry.__init__rcCsHt|tr|j|jdS|jD]}|jdvr6q&||jq&dS)N>errorr) rrrZouter_middleware_update_middlewarervaluesZ event_name _middleware)r.rZobserverr/r/r0rs  zSceneRegistry._setup_middlewarez"NextMiddlewareType[TelegramObject]rr3r)rerr5r6cs@t|tsJdt||j|j|d|d|d<|||IdHS)Nz Event must be an Update instancer&rrrr&r5r)rr rrr)r.rerr5r/r/r0rs z SceneRegistry._update_middlewarecs4|d}t||j||d|d|d<|||IdHS)Nrr&rr)rr)r.rerr5rr/r/r0rs zSceneRegistry._middlewareN)rrvzOptional[Router])rrr6cGst|s td|D]^}|jj|jvr6td|jjd||j|jj<|rX||q|jr|j|qdS)a This method adds the specified scenes to the registry and optionally registers it to the router. If a scene with the same state already exists in the registry, a SceneException is raised. .. warning:: If the router is not specified, the scenes will not be registered to the router. You will need to include the scenes manually to the router or use the register method. :param scenes: A variable length parameter that accepts one or more types of scenes. These scenes are instances of the Scene class. :param router: An optional parameter that specifies the router to which the scenes should be added. :return: None z$At least one scene must be specifiedzScene with state z already existsN) ValueErrorrr&rrZinclude_routerrrr)r.rrr>r/r/r0rszSceneRegistry.add)rr6cGs|j|d|jidS)z Registers one or more scenes to the SceneRegistry. :param scenes: One or more scene classes to register. :return: None rN)rr)r.rr/r/r0r%szSceneRegistry.registerr{r>r6cCszt|rt|tr|jj}t|tr,|j}|durFt|tsFt dz |j |WSt ytt d|dYn0dS)a This method returns the registered Scene object for the specified scene. The scene parameter can be either a Scene object or a string representing the name of the scene. If a Scene object is provided, the state attribute of the SceneConfig object associated with the Scene object will be used as the scene name. If None or an invalid type is provided, a SceneException will be raised. If the specified scene is not registered in the SceneRegistry object, a SceneException will be raised. :param scene: A Scene object or a string representing the name of the scene. :return: The registered Scene object corresponding to the given scene parameter. Nz-Scene must be a subclass of Scene or a stringzScene z is not registered) rnisclassrrrr&rrr$rrKeyError)r.r>r/r/r0rI.s   zSceneRegistry.get)T) rYrZr[rr1rrrrrrIr/r/r/r0rs  " rc@sZeZdZUded<dZded<eddddZeddd d Zeddd d d ZdS)Afterrtr`Nr{r>rCcCs |tjdSNr`)rtrxrr/r/r0rxOsz After.exitcCs |tjdSr)rtryrr/r/r0rySsz After.backrcCs|tj|dS)N)r`r>)rtrw)rr>r/r/r0rWsz After.goto) rYrZr[rr>rrxryrr/r/r/r0rJs  rc@sneZdZdddddZdddd d d d d Zdd dddZd dddZd dddZd dddZdS)ObserverMarkerr$r4rcCs ||_dSrQr)r.r^r/r/r0r1]szObserverMarker.__init__Nrrr]r\)r_rar6cGst|j||dS)Nr)r\r^)r.rar_r/r/r0rr`s zObserverMarker.__call__)r_r6cGst|j|tjdSr)r\r^rtrw)r.r_r/r/r0rwkszObserverMarker.enterrCcCst|jdtjdSNr/r)r\r^rtrurOr/r/r0runszObserverMarker.leavecCst|jdtjdSr)r\r^rtrxrOr/r/r0rxqszObserverMarker.exitcCst|jdtjdSr)r\r^rtryrOr/r/r0rytszObserverMarker.back) rYrZr[r1rrrwrurxryr/r/r/r0r\s rc@seZdZdZedZedZedZedZedZ edZ edZ ed Z ed Z ed Zed Zed ZedZedZdS)OnMarkera} The `OnMarker` class is used as a marker class to define different types of events in the Scenes. Attributes: - :code:`message`: Event marker for handling `Message` events. - :code:`edited_message`: Event marker for handling edited `Message` events. - :code:`channel_post`: Event marker for handling channel `Post` events. - :code:`edited_channel_post`: Event marker for handling edited channel `Post` events. - :code:`inline_query`: Event marker for handling `InlineQuery` events. - :code:`chosen_inline_result`: Event marker for handling chosen `InlineResult` events. - :code:`callback_query`: Event marker for handling `CallbackQuery` events. - :code:`shipping_query`: Event marker for handling `ShippingQuery` events. - :code:`pre_checkout_query`: Event marker for handling `PreCheckoutQuery` events. - :code:`poll`: Event marker for handling `Poll` events. - :code:`poll_answer`: Event marker for handling `PollAnswer` events. - :code:`my_chat_member`: Event marker for handling my chat `Member` events. - :code:`chat_member`: Event marker for handling chat `Member` events. - :code:`chat_join_request`: Event marker for handling chat `JoinRequest` events. - :code:`error`: Event marker for handling `Error` events. .. note:: This is a marker class and does not contain any methods or implementation logic. messageedited_message channel_postedited_channel_post inline_querychosen_inline_resultrshipping_querypre_checkout_querypoll poll_answermy_chat_member chat_memberchat_join_requestN)rYrZr[rrrrrrrrrrrrrrrrr/r/r/r0rxsr)A __future__rrn collectionsrZ dataclassesrrenumrrtypingrr r r r r rrrZtyping_extensionsrZaiogramrZaiogram.dispatcher.dispatcherrZaiogram.dispatcher.event.basesrZ aiogram.dispatcher.event.handlerrrZaiogram.dispatcher.flagsrZaiogram.dispatcher.routerrZaiogram.exceptionsrZaiogram.filtersrZaiogram.fsm.contextrZaiogram.fsm.staterZaiogram.fsm.storage.memoryrZ aiogram.typesrr r!r\rtrsrhrrrrr|rrrrronr/r/r/r0sN  ,           I<5WT,