Linux ns1.utparral.edu.mx 6.8.0-79-generic #79~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Fri Aug 15 16:54:53 UTC 2 x86_64
Apache/2.4.58 (Unix) OpenSSL/1.1.1w PHP/8.2.12 mod_perl/2.0.12 Perl/v5.34.1
: 10.10.1.9 | : 10.10.1.254
Cant Read [ /etc/named.conf ]
daemon
Terminal
AUTO ROOT
Adminer
Backdoor Destroyer
Linux Exploit
Lock Shell
Lock File
Create User
README
+ Create Folder
+ Create File
/
usr /
lib /
python3 /
dist-packages /
defer /
__pycache__ /
[ HOME SHELL ]
Name
Size
Permission
Action
__init__.cpython-310.pyc
16.4
KB
-rw-r--r--
utils.cpython-310.pyc
3.19
KB
-rw-r--r--
version.cpython-310.pyc
157
B
-rw-r--r--
Delete
Unzip
Zip
${this.title}
Close
Code Editor : __init__.cpython-310.pyc
o �r�a�W � @ s� d Z dZdZddlZddlmZ ddlZddlZddl m Z e j Z ej jdkZG d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�Zdd� Zdd� Zdd� Zdd� Zdd� ZdS )z-Small framework for asynchronous programming.z%Sebastian Heinlein <devel@glatzor.de>)�Deferred�AlreadyCalledDeferred�DeferredException�defer�inline_callbacks� return_value� N��wraps� )�version� c @ s e Zd ZdZdd� ZdS )�_DefGen_Returnz5Exception to return a result from an inline callback.c C s || _ d S �N)�value)�selfr � r �0/usr/lib/python3/dist-packages/defer/__init__.py�__init__S s z_DefGen_Return.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r Q s r c @ s e Zd ZdZdS )r z+The Deferred is already running a callback.N)r r r r r r r r r W s r c @ s* e Zd ZdZd dd�Zdd� Zdd� ZdS ) r zAllows to defer exceptions.Nc C sR || _ || _|| _t|t�r|j| _ || _dS |r|s't�� \| _ | _| _dS dS )a� Return a new DeferredException instance. If type, value and traceback are not specified the infotmation will be retreieved from the last caught exception: >>> try: ... raise Exception("Test") ... except: ... deferred_exc = DeferredException() >>> deferred_exc.raise_exception() Traceback (most recent call last): ... Exception: Test Alternatively you can set the exception manually: >>> exception = Exception("Test 2") >>> deferred_exc = DeferredException(exception) >>> deferred_exc.raise_exception() Traceback (most recent call last): ... Exception: Test 2 N)�typer � traceback� isinstance� Exception� __class__�sys�exc_info)r r r r r r r r ^ s �zDeferredException.__init__c C s& t r | j�| j��| �| j��| j��)zRaise the stored exception.)�PY3Kr �with_tracebackr r �r r r r �raise_exception s z!DeferredException.raise_exceptionc G s* |D ] }t | j|�r| S q| �� dS )a8 Check if the stored exception is a subclass of one of the provided exception classes. If this is the case return the matching exception class. Otherwise raise the stored exception. >>> exc = DeferredException(SystemError()) >>> exc.catch(Exception) # Will catch the exception and return it <class 'Exception'> >>> exc.catch(OSError) # Won't catch and raise the stored exception Traceback (most recent call last): ... SystemError This method can be used in errbacks of a Deferred: >>> def dummy_errback(deferred_exception): ... '''Error handler for OSError''' ... deferred_exception.catch(OSError) ... return "catched" The above errback can handle an OSError: >>> deferred = Deferred() >>> deferred.add_errback(dummy_errback) >>> deferred.errback(OSError()) >>> deferred.result 'catched' But fails to handle a SystemError: >>> deferred2 = Deferred() >>> deferred2.add_errback(dummy_errback) >>> deferred2.errback(SystemError()) >>> deferred2.result #doctest: +ELLIPSIS <defer.DeferredException object at 0x...> >>> deferred2.result.value SystemError() N)� issubclassr r" )r �errors�errr r r �catch� s & � zDeferredException.catch)NNN)r r r r r r" r& r r r r r [ s ! r c @ s\ e Zd ZdZdd� Z ddd�Zdd� Zd d � Zdd d �Zdd d�Z dd� Z dd� Z dS )r a� The Deferred allows to chain callbacks. There are two type of callbacks: normal callbacks and errbacks, which handle an exception in a normal callback. The callbacks are processed in pairs consisting of a normal callback and an errback. A normal callback will return its result to the callback of the next pair. If an exception occurs, it will be handled by the errback of the next pair. If an errback doesn't raise an error again, the callback of the next pair will be called with the return value of the errback. Otherwise the exception of the errback will be returned to the errback of the next pair:: CALLBACK1 ERRBACK1 | \ / | result failure result failure | \ / | | \ / | | X | | / \ | | / \ | | / \ | CALLBACK2 ERRBACK2 | \ / | result failure result failure | \ / | | \ / | | X | | / \ | | / \ | | / \ | CALLBACK3 ERRBACK3 c C s" g | _ g | _d| _d| _d| _dS )z Return a new Deferred instance.FN)� callbacks�errbacks�called�paused�_runningr! r r r r � s zDeferred.__init__Nc C s~ t |tjj�s J �|du st |tjj�sJ �|du r t}| j�||p#g |p&i f|p*t|p-g |p0i ff� | jr=| �� dS dS )aA Add a pair of callables (function or method) to the callback and errback chain. Keyword arguments: callback -- the next chained challback errback -- the next chained errback callback_args -- list of additional arguments for the callback callback_kwargs -- dict of additional arguments for the callback errback_args -- list of additional arguments for the errback errback_kwargs -- dict of additional arguments for the errback In the following example the first callback pairs raises an exception that is catched by the errback of the second one and processed by the third one. >>> def callback(previous): ... '''Return the previous result.''' ... return "Got: %s" % previous >>> def callback_raise(previous): ... '''Fail and raise an exception.''' ... raise Exception("Test") >>> def errback(error): ... '''Recover from an exception.''' ... #error.catch(Exception) ... return "catched" >>> deferred = Deferred() >>> deferred.callback("start") >>> deferred.result 'start' >>> deferred.add_callbacks(callback_raise, errback) >>> deferred.result #doctest: +ELLIPSIS <defer.DeferredException object at 0x...> >>> deferred.add_callbacks(callback, errback) >>> deferred.result 'catched' >>> deferred.add_callbacks(callback, errback) >>> deferred.result 'Got: catched' N) r � collections�abc�Callable� _passthroughr' �appendr) �_next)r �callback�errback� callback_args�callback_kwargs� errback_args�errback_kwargsr r r � add_callbacks� s *��� �zDeferred.add_callbacksc O s | j t|||d� dS )a~ Add a callable (function or method) to the errback chain only. If there isn't any exception the result will be passed through to the callback of the next pair. The first argument is the callable instance followed by any additional argument that will be passed to the errback. The errback method will get the most recent DeferredException and and any additional arguments that was specified in add_errback. If the errback can catch the exception it can return a value that will be passed to the next callback in the chain. Otherwise the errback chain will not be processed anymore. See the documentation of defer.DeferredException.catch for further information. >>> def catch_error(deferred_error, ignore=False): ... if ignore: ... return "ignored" ... deferred_error.catch(Exception) ... return "catched" >>> deferred = Deferred() >>> deferred.errback(SystemError()) >>> deferred.add_errback(catch_error, ignore=True) >>> deferred.result 'ignored' )r6 r7 N�r8 r/ �r �func�args�kwargsr r r � add_errback s �zDeferred.add_errbackc O s | j |t||d� dS )a� Add a callable (function or method) to the callback chain only. An error would be passed through to the next errback. The first argument is the callable instance followed by any additional argument that will be passed to the callback. The callback method will get the result of the previous callback and any additional arguments that was specified in add_callback. >>> def callback(previous, counter=False): ... if counter: ... return previous + 1 ... return previous >>> deferred = Deferred() >>> deferred.add_callback(callback, counter=True) >>> deferred.callback(1) >>> deferred.result 2 )r4 r5 Nr9 r: r r r � add_callback5 s �zDeferred.add_callbackc C sV | j rt� �|s t� }nt|t�s t|t�sJ �t|j|d�}d| _ || _| �� dS )a� Start processing the errorback chain starting with the provided exception or DeferredException. If an exception is specified it will be wrapped into a DeferredException. It will be send to the first errback or stored as finally result if not any further errback has been specified yet. >>> deferred = Deferred() >>> deferred.errback(Exception("Test Error")) >>> deferred.result #doctest: +ELLIPSIS <defer.DeferredException object at 0x...> >>> deferred.result.raise_exception() Traceback (most recent call last): ... Exception: Test Error NT)r) r r r r r �resultr1 )r �errorr r r r3 M s zDeferred.errbackc C s$ | j rt� �d| _ || _| �� dS )aO Start processing the callback chain starting with the provided result. It will be send to the first callback or stored as finally one if not any further callback has been specified yet. >>> deferred = Deferred() >>> deferred.callback("done") >>> deferred.result 'done' TN)r) r r@ r1 �r r@ r r r r2 i s zDeferred.callbackc C s" || _ d| _| jr| �� dS dS )z7Continue processing the Deferred with the given result.FN)r@ r* r) r1 rB r r r � _continue{ s �zDeferred._continuec C s� | j s| jrdS | jrV| j�d�}|t| jt� \}}}z z|| jg|�R i |��| _W n t� | _Y W d| _ nd| _ w t| jt�rS| j�| j | j � | jdk n| js t| jt�rkt � | jj | jj | jj� dS dS )zProcess the next callback.Nr FT)r+ r* r' �popr r@ r r r8 rC r � excepthookr r r )r � next_pairr2 r< r= r r r r1 � s0 � � � ��zDeferred._next)NNNNNr ) r r r r r r8 r> r? r3 r2 rC r1 r r r r r � s " �7! r c O sV t | tjj�s J �z | |i |��}W n t� }Y t |t�r!|S t� }|�|� |S )a� Invoke the given function that may or not may be a Deferred. If the return object of the function call is a Deferred return, it. Otherwise wrap it into a Deferred. >>> defer(lambda x: x, 10) #doctest: +ELLIPSIS <defer.Deferred object at 0x...> >>> deferred = defer(lambda x: x, "done") >>> deferred.result 'done' >>> deferred = Deferred() >>> defer(lambda: deferred) == deferred True )r r, r- r. r r r2 )r; r< r= r@ �deferredr r r r � s r c C s | S r r )�argr r r r/ � s r/ c C s t | ��)a� Return val from a inline_callbacks generator. Note: this is currently implemented by raising an exception derived from BaseException. You might want to change any 'except:' clauses to an 'except Exception:' clause so as not to catch this exception. Also: while this function currently will work when called from within arbitrary functions called from within the generator, do not rely upon this behavior. )r )�valr r r r � s r c s� ddg� z+t | t�}|r*tr | j�| j�}��|�} n��| �| j��| j��} n��| �} W nm t y@ � � d� � Y S t y� } zHt � � d j}|rS|j}|jr�|jjr�|}|jjrg|j}|jjs`|jjj}|j} t�d|jjj|jjjf t|| � � � |j� � W Y d}~S d}~w � �� � Y S t | t�rLJ ��fdd�} | �| | � �d r�d �d< � S �d } d�d< d�d< q) z See inlineCallbacks. TNr r zvreturnValue() in %r causing %r to exit: returnValue should only be invoked by functions decorated with inlineCallbacksc s, �d rd�d< | �d< d S t | �� � d S )Nr Fr )�_inline_callbacks)�res�rG �gen�waitingr r � gotResult s z$_inline_callbacks.<locals>.gotResultr F)r r r r r r �throwr �send� StopIterationr2 r r r �tb_next�tb_frame�f_code� co_filename� tb_lineno�warnings� warn_explicit�co_name�DeprecationWarningr3 r r8 ) r@ rM rG � is_failure�excepr% � appCodeTrace� ultimateTrace�filename�linenorO r rL r rJ � sf � � � ��� � �rJ c s t � �� fdd��}|S )a inline_callbacks helps you write Deferred-using code that looks like a regular sequential function. For example:: def thingummy(): thing = yield makeSomeRequestResultingInDeferred() print thing #the result! hoorj! thingummy = inline_callbacks(thingummy) When you call anything that results in a Deferred, you can simply yield it; your generator will automatically be resumed when the Deferred's result is available. The generator will be sent the result of the Deferred with the 'send' method on generators, or if the result was a failure, 'throw'. Your inline_callbacks-enabled generator will return a Deferred object, which will result in the return value of the generator (or will fail with a failure object if your generator raises an unhandled exception). Note that you can't use return result to return a value; use return_value(result) instead. Falling off the end of the generator, or simply using return will cause the Deferred to have a result of None. The Deferred returned from your deferred generator may errback if your generator raised an exception:: def thingummy(): thing = yield makeSomeRequestResultingInDeferred() if thing == 'I love Twisted': # will become the result of the Deferred return_value('TWISTED IS GREAT!') else: # will trigger an errback raise Exception('DESTROY ALL LIFE') thingummy = inline_callbacks(thingummy) c s t d � | i |��t� �S r )rJ r )r< r= �r; r r �unwind_generatorS s z*inline_callbacks.<locals>.unwind_generatorr )r; rc r rb r r 1 s "r ) r � __author__�__all__�collections.abcr, � functoolsr r rX � r �VERSION� __version__� version_info�majorr � BaseExceptionr r r �objectr r r r/ r rJ r r r r r �<module> s( < W q a
Close