File: //lib/python3/dist-packages/twisted/internet/__pycache__/interfaces.cpython-312.pyc
�
�b � � � d Z ddlmZmZmZmZmZmZmZm Z m
Z
m Z m Z ddl
mZmZ ddlmZ ergddlmZ ddlmZmZ ddlm Z ddl m Z m Z m Z dd l!m"Z" dd
l#m$Z$m%Z%m&Z&m'Z'm(Z( dd l)m*Z* dd l+m,Z,m-Z- dd
l.m/Z/ ddl0m1Z1 e1jd � rddl3m4Z4 neZ4 G d� de� Z5 G d� de� Z6 G d� de� Z7 G d� de� Z8 G d� de� Z9 G d� de� Z: G d � d e7� Z; G d � d e� Z< G d � d!e� Z= G d"� d#e� Z> G d$� d%e� Z? G d&� d'e� Z@ G d(� d)e� ZA G d*� d+e� ZB G d,� d-e� ZC G d.� d/e� ZD G d0� d1e� ZE G d2� d3e� ZF G d4� d5e� ZG G d6� d7e� ZH G d8� d9eGeH� ZI G d:� d;e� ZJ G d<� d=e� ZK G d>� d?e� ZL G d@� dAe� ZM G dB� dCe� ZN G dD� dEe� ZO G dF� dGe� ZP G dH� dIeP� ZQ G dJ� dKeQ� ZR G dL� dMeQ� ZS G dN� dOeReS� ZT G dP� dQe� ZU G dR� dSe� ZV G dT� dUe� ZW G dV� dWe� ZX G dX� dYeX� ZY G dZ� d[eX� ZZ G d\� d]e� Z[ G d^� d_e� Z\ G d`� dae� Z] G db� dce� Z^ G dd� dee� Z_ G df� dge� Z` G dh� die� Za G dj� dkea� Zb G dl� dmea� Zc G dn� doe� Zd G dp� dqe� Ze G dr� dse� Zf G dt� due� Zg G dv� dweb� Zh G dx� dyeb� Zi G dz� d{ei� Zj G d|� d}e� Zk G d~� de� Zl G d�� d�ea� Zm G d�� d�e� Zn G d�� d�e� Zo G d�� d�e� Zp G d�� d�e� Zq G d�� d�e� Zr G d�� d�e� Zs G d�� d�e� Zt G d�� d�e� Zu G d�� d�e� Zv G d�� d�e� Zwy�# e$ r exZZY ��Hw xY w)�z>
Interface documentation.
Maintainer: Itamar Shtull-Trauring
� ) �
TYPE_CHECKING�Any�AnyStr�Callable�Iterable�List�Mapping�Optional�Sequence�Tuple�Union)� Attribute� Interface)�Failure)�
AddressFamily)�
Connection�Context)�FileDescriptor)� IPv4Address� IPv6Address� UNIXAddress)�Deferred)�
ClientFactory�ConnectedDatagramProtocol�DatagramProtocol�Factory�
ServerFactory)�ClientContextFactory)�Query�RRHeader)�TLSMemoryBIOProtocol)�platform)�
ThreadPoolc � � e Zd ZdZy)�IAddresszr
An address, e.g. a TCP C{(host, port)}.
Default implementations are in L{twisted.internet.address}.
N��__name__�
__module__� __qualname__�__doc__� � �=/usr/lib/python3/dist-packages/twisted/internet/interfaces.pyr% r% < s � �r, r% c �4 � e Zd ZdZdd�Zdd�Zdd�Zdefd�Zy) �
IConnectorzu
Object used to interface between connections and protocols.
Each L{IConnector} manages one connection.
�returnNc � � y)z-
Stop attempting to connect.
Nr+ r+ r, r- �stopConnectingzIConnector.stopConnectingN � � r, c � � y)z�
Disconnect regardless of the connection state.
If we are connected, disconnect, if we are trying to connect,
stop trying.
Nr+ r+ r, r- �
disconnectzIConnector.disconnectS r3 r, c � � y)z3
Try to connect to remote address.
Nr+ r+ r, r- �connectzIConnector.connect[ r3 r, c � � y)zy
Return destination this will try to connect to.
@return: An object which provides L{IAddress}.
Nr+ r+ r, r- �getDestinationzIConnector.getDestination` r3 r, �r0 N) r' r( r) r* r2 r5 r7 r% r9 r+ r, r- r/ r/ G s" � �� �
� �
�H� r, r/ c �& � e Zd Zdedee ddfd�Zy)�IResolverSimple�name�timeoutr0 �
Deferred[str]c � � y)a�
Resolve the domain name C{name} into an IP address.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: The callback of the Deferred that is returned will be
passed a string that represents the IP address of the
specified name, or the errback will be called if the
lookup times out. If multiple types of address records
are associated with the name, A6 records will be returned
in preference to AAAA records, which will be returned in
preference to A records. If there are multiple records of
the type to be returned, one will be selected at random.
@raise twisted.internet.defer.TimeoutError: Raised
(asynchronously) if the name cannot be resolved within the
specified timeout period.
Nr+ �r= r> s r- �
getHostByNamez IResolverSimple.getHostByNamei r3 r, N)r' r( r) �strr �intrB r+ r, r- r< r< h s � � �C� �(�3�-� �O� r, r< c �( � e Zd ZdZ ed� Zdd�Zy)�IHostResolutionz�
An L{IHostResolution} represents represents an in-progress recursive query
for a DNS name.
@since: Twisted 17.1.0
zB
L{unicode}; the name of the host being resolved.
Nc � � y)z;
Stop the hostname resolution in progress.
Nr+ r+ r, r- �cancelzIHostResolution.cancel� r3 r, r: )r' r( r) r* r r= rH r+ r, r- rF rF � s � �� � � �D� r, rF c �8 � e Zd ZdZdeddfd�Zdeddfd�Zd d�Zy)
�IResolutionReceiverz�
An L{IResolutionReceiver} receives the results of a hostname resolution in
progress, initiated by an L{IHostnameResolver}.
@since: Twisted 17.1.0
�resolutionInProgressr0 Nc � � y)zk
A hostname resolution began.
@param resolutionInProgress: an L{IHostResolution}.
Nr+ )rK s r- �resolutionBeganz#IResolutionReceiver.resolutionBegan� r3 r, �addressc � � y)a�
An internet address. This is called when an address for the given name
is discovered. In the current implementation this practically means
L{IPv4Address} or L{IPv6Address}, but implementations of this interface
should be lenient to other types being passed to this interface as
well, for future-proofing.
@param address: An address object.
Nr+ )rN s r- �addressResolvedz#IResolutionReceiver.addressResolved� r3 r, c � � y)z�
Resolution has completed; no further addresses will be relayed to
L{IResolutionReceiver.addressResolved}.
Nr+ r+ r, r- �resolutionCompletez&IResolutionReceiver.resolutionComplete� r3 r, r: ) r' r( r) r* rF rM r% rP rR r+ r, r- rJ rJ � s2 � �� �o� �$� � �� �d� � r, rJ c �6 � e Zd ZdZdedededee dedef d�Z y )
�IHostnameResolverz�
An L{IHostnameResolver} can resolve a host name and port number into a
series of L{IAddress} objects.
@since: Twisted 17.1.0
�resolutionReceiver�hostName�
portNumber� addressTypes�transportSemanticsr0 c � � y)a�
Initiate a hostname resolution.
@param resolutionReceiver: an object that will receive each resolved
address as it arrives.
@param hostName: The name of the host to resolve. If this contains
non-ASCII code points, they will be converted to IDNA first.
@param portNumber: The port number that the returned addresses should
include.
@param addressTypes: An iterable of implementors of L{IAddress} that
are acceptable values for C{resolutionReceiver} to receive to its
L{addressResolved <IResolutionReceiver.addressResolved>}. In
practice, this means an iterable containing
L{twisted.internet.address.IPv4Address},
L{twisted.internet.address.IPv6Address}, both, or neither.
@param transportSemantics: A string describing the semantics of the
transport; either C{'TCP'} for stream-oriented transports or
C{'UDP'} for datagram-oriented; see
L{twisted.internet.address.IPv6Address.type} and
L{twisted.internet.address.IPv4Address.type}.
@return: The resolution in progress.
Nr+ )rU rV rW rX rY s r- �resolveHostNamez!IHostnameResolver.resolveHostName� r3 r, N)
r' r( r) r* rJ rC rD r r% r[ r+ r, r- rT rT � sI � �� � /� �� � � � �x�(� �
� �
�
r, rT c �| � e Zd Zdddee ddfd�Zdedee ddfd�Zdedee ddfd �Zdedee ddfd
�Z dedee ddfd �Z
dedee ddfd �Z dedee ddfd
�Z dedee ddfd�Z
dedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd�Zdedee ddfd �Zdedee ddfd �Z dedee ddfd �Z y ) � IResolver�queryr r> r0 z-Deferred[Tuple[RRHeader, RRHeader, RRHeader]]c � � y)a&
Dispatch C{query} to the method which can handle its type.
@param query: The DNS query being issued, to which a response is to be
generated.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ )r^ r> s r- r^ zIResolver.query� r3 r, r= c � � y)a�
Perform an A record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �
lookupAddresszIResolver.lookupAddress� r3 r, c � � y)a�
Perform an A6 record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupAddress6zIResolver.lookupAddress6 r3 r, c � � y)a�
Perform an AAAA record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupIPV6AddresszIResolver.lookupIPV6Address r3 r, c � � y)a�
Perform an MX record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupMailExchangez IResolver.lookupMailExchange+ r3 r, c � � y)a�
Perform an NS record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupNameserverszIResolver.lookupNameservers> r3 r, c � � y)a�
Perform a CNAME record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupCanonicalNamez IResolver.lookupCanonicalNameQ r3 r, c � � y)a�
Perform an MB record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �
lookupMailBoxzIResolver.lookupMailBoxd r3 r, c � � y)a�
Perform an MG record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupMailGroupzIResolver.lookupMailGroupw r3 r, c � � y)a�
Perform an MR record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupMailRenamezIResolver.lookupMailRename� r3 r, c � � y)a�
Perform a PTR record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �
lookupPointerzIResolver.lookupPointer� r3 r, c � � y)a�
Perform an SOA record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupAuthorityzIResolver.lookupAuthority� r3 r, c � � y)a�
Perform a NULL record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �
lookupNullzIResolver.lookupNull� r3 r, c � � y)a�
Perform a WKS record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupWellKnownServicesz!IResolver.lookupWellKnownServices� r3 r, c � � y)a�
Perform a HINFO record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupHostInfozIResolver.lookupHostInfo� r3 r, c � � y)a�
Perform an MINFO record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupMailboxInfozIResolver.lookupMailboxInfo� r3 r, c � � y)a�
Perform a TXT record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �
lookupTextzIResolver.lookupText r3 r, c � � y)a�
Perform an RP record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupResponsibilityz IResolver.lookupResponsibility" r3 r, c � � y)a�
Perform an AFSDB record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupAFSDatabasezIResolver.lookupAFSDatabase5 r3 r, c � � y)a�
Perform an SRV record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �
lookupServicezIResolver.lookupServiceH r3 r, c � � y)a�
Perform an ALL_RECORD lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupAllRecordszIResolver.lookupAllRecords[ r3 r, c � � y)a�
Perform a SPF record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �lookupSenderPolicyz IResolver.lookupSenderPolicyn r3 r, c � � y)a�
Perform a NAPTR record lookup.
@param name: DNS name to resolve.
@param timeout: Number of seconds after which to reissue the query.
When the last timeout expires, the query is considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances. The first element of the
tuple gives answers. The second element of the tuple gives
authorities. The third element of the tuple gives additional
information. The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- � lookupNamingAuthorityPointerz&IResolver.lookupNamingAuthorityPointer� r3 r, c � � y)aT
Perform an AXFR record lookup.
NB This is quite different from other DNS requests. See
U{http://cr.yp.to/djbdns/axfr-notes.html} for more
information.
NB Unlike other C{lookup*} methods, the timeout here is not a
list of ints, it is a single int.
@param name: DNS name to resolve.
@param timeout: When this timeout expires, the query is
considered failed.
@return: A L{Deferred} which fires with a three-tuple of lists of
L{twisted.names.dns.RRHeader} instances.
The first element of the tuple gives answers.
The second and third elements are always empty.
The L{Deferred} may instead fail with one of the
exceptions defined in L{twisted.names.error} or with
C{NotImplementedError}.
Nr+ rA s r- �
lookupZonezIResolver.lookupZone� r3 r, N) r' r( r) r rD r^ rC ra rc re rg ri rk rm ro rq rs ru rw ry r{ r} r r� r� r� r� r� r� r� r+ r, r- r] r] � s � � �� �!)�#� � � 8� �( �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� �& �� � $�S�M� � 8� r, r] c
�X � e Zd Zdedddededdf
d�Zd ededd
d ed eeeef de f d
�Z
y)� IReactorTCP�port�factoryr �backlog� interfacer0 �IListeningPortc � � y)a6
Connects a given protocol factory to the given numeric TCP/IP port.
@param port: a port number on which to listen
@param factory: a L{twisted.internet.protocol.ServerFactory} instance
@param backlog: size of the listen queue
@param interface: The local IPv4 or IPv6 address to which to bind;
defaults to '', ie all IPv4 addresses. To bind to all IPv4 and IPv6
addresses, you must call this method twice.
@return: an object that provides L{IListeningPort}.
@raise CannotListenError: as defined here
L{twisted.internet.error.CannotListenError},
if it cannot listen on this port (e.g., it
cannot bind to the required port number)
Nr+ )r� r� r� r� s r- � listenTCPzIReactorTCP.listenTCP� r3 r, �hostr r> � bindAddressc � � y)a�
Connect a TCP client.
@param host: A hostname or an IPv4 or IPv6 address literal.
@param port: a port number
@param factory: a L{twisted.internet.protocol.ClientFactory} instance
@param timeout: number of seconds to wait before assuming the
connection has failed.
@param bindAddress: a (host, port) tuple of local address to bind
to, or None.
@return: An object which provides L{IConnector}. This connector will
call various callbacks on the factory when a connection is
made, failed, or lost - see
L{ClientFactory<twisted.internet.protocol.ClientFactory>}
docs for details.
Nr+ )r� r� r� r> r� s r- �
connectTCPzIReactorTCP.connectTCP� r3 r, N) r' r( r) rD rC r� �floatr
r r/ r� r+ r, r- r� r� � sy � � �� � +� �69� �FI� � � �* �� �� � !� � � �
�e�C��H�o�.� �
�
r, r� c �` � e Zd Zdededddddedeeeef d efd
�Z dedd dd d
eded ef d�Z
y)� IReactorSSLr� r� r� r �contextFactoryr r> r� r0 c � � y)aQ
Connect a client Protocol to a remote SSL socket.
@param host: a host name
@param port: a port number
@param factory: a L{twisted.internet.protocol.ClientFactory} instance
@param contextFactory: a L{twisted.internet.ssl.ClientContextFactory} object.
@param timeout: number of seconds to wait before assuming the
connection has failed.
@param bindAddress: a (host, port) tuple of local address to bind to,
or L{None}.
@return: An object which provides L{IConnector}.
Nr+ )r� r� r� r� r> r� s r- �
connectSSLzIReactorSSL.connectSSL� r3 r, r �IOpenSSLContextFactoryr� r� c � � y)a�
Connects a given protocol factory to the given numeric TCP/IP port.
The connection is a SSL one, using contexts created by the context
factory.
@param port: a port number on which to listen
@param factory: a L{twisted.internet.protocol.ServerFactory} instance
@param contextFactory: an implementor of L{IOpenSSLContextFactory}
@param backlog: size of the listen queue
@param interface: the hostname to bind to, defaults to '' (all)
Nr+ )r� r� r� r� r� s r- � listenSSLzIReactorSSL.listenSSL� r3 r, N) r' r( r) rC rD r� r
r r/ r� r� r+ r, r- r� r� � s� � � �� �� � !� � /� �
� � �e�C��H�o�.�
�
� �. �� � � � 1� � � �
� �
�
r, r� c �L � e Zd ZdZdedddededef
d�Zdedd d
e d e d edd
f d�Z
y)� IReactorUNIXz
UNIX socket methods.
rN r� r r> �checkPIDr0 c � � y)a1
Connect a client protocol to a UNIX socket.
@param address: a path to a unix socket on the filesystem.
@param factory: a L{twisted.internet.protocol.ClientFactory} instance
@param timeout: number of seconds to wait before assuming the connection
has failed.
@param checkPID: if True, check for a pid file to verify that a server
is listening. If C{address} is a Linux abstract namespace path,
this must be C{False}.
@return: An object which provides L{IConnector}.
Nr+ )rN r� r> r� s r- � connectUNIXzIReactorUNIX.connectUNIX r3 r, r r� �mode�wantPIDr� c � � y)a�
Listen on a UNIX socket.
@param address: a path to a unix socket on the filesystem.
@param factory: a L{twisted.internet.protocol.Factory} instance.
@param backlog: number of connections to allow in backlog.
@param mode: The mode (B{not} umask) to set on the unix socket. See
platform specific documentation for information about how this
might affect connection attempts.
@param wantPID: if True, create a pidfile for the socket. If C{address}
is a Linux abstract namespace path, this must be C{False}.
@return: An object which provides L{IListeningPort}.
Nr+ )rN r� r� r� r� s r- �
listenUNIXzIReactorUNIX.listenUNIX! r3 r, N) r' r( r) r* rC r� �boolr/ r� rD r� r+ r, r- r� r� si � �� �� � .� �9>� �JN� � � �" �� � (� �36� �>A� �LP� � � r, r� c
�\ � e Zd ZdZdedddededeeeef def d �Z dedd
dededd f
d �Z
y
)�IReactorUNIXDatagramz'
Datagram UNIX socket methods.
rN �protocolr �
maxPacketSizer� r� r0 c � � y)aQ
Connect a client protocol to a datagram UNIX socket.
@param address: a path to a unix socket on the filesystem.
@param protocol: a L{twisted.internet.protocol.ConnectedDatagramProtocol} instance
@param maxPacketSize: maximum packet size to accept
@param mode: The mode (B{not} umask) to set on the unix socket. See
platform specific documentation for information about how this
might affect connection attempts.
@param bindAddress: address to bind to
@return: An object which provides L{IConnector}.
Nr+ )rN r� r� r� r� s r- �connectUNIXDatagramz(IReactorUNIXDatagram.connectUNIXDatagram9 r3 r, r r� c � � y)a
Listen on a datagram UNIX socket.
@param address: a path to a unix socket on the filesystem.
@param protocol: a L{twisted.internet.protocol.DatagramProtocol} instance.
@param maxPacketSize: maximum packet size to accept
@param mode: The mode (B{not} umask) to set on the unix socket. See
platform specific documentation for information about how this
might affect connection attempts.
@return: An object which provides L{IListeningPort}.
Nr+ )rN r� r� r� s r- �listenUNIXDatagramz'IReactorUNIXDatagram.listenUNIXDatagramO r3 r, N) r' r( r) r* rC rD r
r r/ r� r� r+ r, r- r� r� 4 s~ � �� �� �-� � � � � �
�e�C��H�o�.� �
�
�, �� � 2� �CF� �NQ� � � r, r� c �8 � e Zd ZdZdedddeddfd�Zdeddfd �Zy)
�IReactorWin32Eventsz3
Win32 Event API methods
@since: 10.2
�event�fdr �actionr0 Nc � � y)al
Add a new win32 event to the event loop.
@param event: a Win32 event object created using win32event.CreateEvent()
@param fd: an instance of L{twisted.internet.abstract.FileDescriptor}
@param action: a string that is a method name of the fd instance.
This method is called in response to the event.
Nr+ )r� r� r� s r- �addEventz IReactorWin32Events.addEventg r3 r, c � � y)z�
Remove an event.
@param event: a Win32 event object added using L{IReactorWin32Events.addEvent}
@return: None
Nr+ )r� s r- � removeEventz IReactorWin32Events.removeEventq r3 r, )r' r( r) r* �objectrC r� r� r+ r, r- r� r� ` s< � �� �� �$4� �c� �d� � �6� �d� r, r� c
�, � e Zd ZdZdedddededdf
d �Zy
) � IReactorUDPz
UDP socket methods.
r� r� r r� r� r0 r� c � � y)a�
Connects a given L{DatagramProtocol} to the given numeric UDP port.
@param port: A port number on which to listen.
@param protocol: A L{DatagramProtocol} instance which will be
connected to the given C{port}.
@param interface: The local IPv4 or IPv6 address to which to bind;
defaults to '', ie all IPv4 addresses.
@param maxPacketSize: The maximum packet size to accept.
@return: object which provides L{IListeningPort}.
Nr+ )r� r� r� r� s r- � listenUDPzIReactorUDP.listenUDP� r3 r, N)r' r( r) r* rD rC r� r+ r, r- r� r� { s4 � �� �� � /� �<?� �PS� � � r, r� c �0 � e Zd ZdZdedddedededd f d
�Zy ) �IReactorMulticastz�
UDP socket methods that support multicast.
IMPORTANT: This is an experimental new interface. It may change
without backwards compatibility. Suggestions are welcome.
r� r� r r� r� �listenMultipler0 r� c � � y)a�
Connects a given
L{DatagramProtocol<twisted.internet.protocol.DatagramProtocol>} to the
given numeric UDP port.
@param listenMultiple: If set to True, allows multiple sockets to
bind to the same address and port number at the same time.
@returns: An object which provides L{IListeningPort}.
@see: L{twisted.internet.interfaces.IMulticastTransport}
@see: U{http://twistedmatrix.com/documents/current/core/howto/udp.html}
Nr+ )r� r� r� r� r� s r- �listenMulticastz!IReactorMulticast.listenMulticast� r3 r, N)r' r( r) r* rD rC r� r� r+ r, r- r� r� � sD � �� �� �$� � � � � �
� �
�
r, r� c
�\ � e Zd ZdZdeddddddfd �Zdedddddd
fd �Zdeddd d
deddf
d�Zy
)�IReactorSocketa
Methods which allow a reactor to use externally created sockets.
For example, to use C{adoptStreamPort} to implement behavior equivalent
to that of L{IReactorTCP.listenTCP}, you might write code like this::
from socket import SOMAXCONN, AF_INET, SOCK_STREAM, socket
portSocket = socket(AF_INET, SOCK_STREAM)
# Set FD_CLOEXEC on port, left as an exercise. Then make it into a
# non-blocking listening port:
portSocket.setblocking(False)
portSocket.bind(('192.168.1.2', 12345))
portSocket.listen(SOMAXCONN)
# Now have the reactor use it as a TCP port
port = reactor.adoptStreamPort(
portSocket.fileno(), AF_INET, YourFactory())
# portSocket itself is no longer necessary, and needs to be cleaned
# up by us.
portSocket.close()
# Whenever the server is no longer needed, stop it as usual.
stoppedDeferred = port.stopListening()
Another potential use is to inherit a listening descriptor from a parent
process (for example, systemd or launchd), or to receive one over a UNIX
domain socket.
Some plans for extending this interface exist. See:
- U{http://twistedmatrix.com/trac/ticket/6594}: AF_UNIX SOCK_DGRAM ports
�fileDescriptor�
addressFamilyr r� r r0 r� c � � y)a
Add an existing listening I{SOCK_STREAM} socket to the reactor to
monitor for new connections to accept and handle.
@param fileDescriptor: A file descriptor associated with a socket which
is already bound to an address and marked as listening. The socket
must be set non-blocking. Any additional flags (for example,
close-on-exec) must also be set by application code. Application
code is responsible for closing the file descriptor, which may be
done as soon as C{adoptStreamPort} returns.
@param addressFamily: The address family (or I{domain}) of the socket.
For example, L{socket.AF_INET6}.
@param factory: A L{ServerFactory} instance to use to create new
protocols to handle connections accepted via this socket.
@return: An object providing L{IListeningPort}.
@raise twisted.internet.error.UnsupportedAddressFamily: If the
given address family is not supported by this reactor, or
not supported with the given socket type.
@raise twisted.internet.error.UnsupportedSocketType: If the
given socket type is not supported by this reactor, or not
supported with the given socket type.
Nr+ �r� r� r� s r- �adoptStreamPortz IReactorSocket.adoptStreamPort� r3 r, Nc � � y)a
Add an existing connected I{SOCK_STREAM} socket to the reactor to
monitor for data.
Note that the given factory won't have its C{startFactory} and
C{stopFactory} methods called, as there is no sensible time to call
them in this situation.
@param fileDescriptor: A file descriptor associated with a socket which
is already connected. The socket must be set non-blocking. Any
additional flags (for example, close-on-exec) must also be set by
application code. Application code is responsible for closing the
file descriptor, which may be done as soon as
C{adoptStreamConnection} returns.
@param addressFamily: The address family (or I{domain}) of the socket.
For example, L{socket.AF_INET6}.
@param factory: A L{ServerFactory} instance to use to create a new
protocol to handle the connection via this socket.
@raise UnsupportedAddressFamily: If the given address family is not
supported by this reactor, or not supported with the given socket
type.
@raise UnsupportedSocketType: If the given socket type is not supported
by this reactor, or not supported with the given socket type.
Nr+ r� s r- �adoptStreamConnectionz$IReactorSocket.adoptStreamConnection� r3 r, r� r r� c � � y)a�
Add an existing listening I{SOCK_DGRAM} socket to the reactor to
monitor for read and write readiness.
@param fileDescriptor: A file descriptor associated with a socket which
is already bound to an address and marked as listening. The socket
must be set non-blocking. Any additional flags (for example,
close-on-exec) must also be set by application code. Application
code is responsible for closing the file descriptor, which may be
done as soon as C{adoptDatagramPort} returns.
@param addressFamily: The address family or I{domain} of the socket.
For example, L{socket.AF_INET6}.
@param protocol: A L{DatagramProtocol} instance to connect to
a UDP transport.
@param maxPacketSize: The maximum packet size to accept.
@return: An object providing L{IListeningPort}.
@raise UnsupportedAddressFamily: If the given address family is not
supported by this reactor, or not supported with the given socket
type.
@raise UnsupportedSocketType: If the given socket type is not supported
by this reactor, or not supported with the given socket type.
Nr+ )r� r� r� r� s r- �adoptDatagramPortz IReactorSocket.adoptDatagramPort r3 r, )r' r( r) r* rD r� r� r� r+ r, r- r� r� � s� � � �D �� �,;� �FU� � � �8 �� �,;� �FU� �
� �: �� �&� � %� � � �
� r, r� c � � e Zd Zdddeeef deeeef deee e f deeef de
de
d e d
ee
ee
ef f d d fd
�Z y)�IReactorProcess�processProtocol�IProcessProtocol�
executable�args�env�path�uid�gid�usePTY�childFDsr0 �IProcessTransportc � � y)aJ
Spawn a process, with a process protocol.
Arguments given to this function that are listed as L{bytes} or
L{unicode} may be encoded or decoded depending on the platform and the
argument type given. On UNIX systems (Linux, FreeBSD, macOS) and
Python 2 on Windows, L{unicode} arguments will be encoded down to
L{bytes} using the encoding given by L{sys.getfilesystemencoding}, to be
used with the "narrow" OS APIs. On Python 3 on Windows, L{bytes}
arguments will be decoded up to L{unicode} using the encoding given by
L{sys.getfilesystemencoding} (C{mbcs} before Python 3.6, C{utf8}
thereafter) and given to Windows's native "wide" APIs.
@param processProtocol: An object which will be notified of all events
related to the created process.
@param executable: the file name to spawn - the full path should be
used.
@param args: the command line arguments to pass to the process; a
sequence of strings. The first string should be the executable's
name.
@param env: the environment variables to pass to the child process.
The resulting behavior varies between platforms. If:
- C{env} is not set:
- On POSIX: pass an empty environment.
- On Windows: pass L{os.environ}.
- C{env} is L{None}:
- On POSIX: pass L{os.environ}.
- On Windows: pass L{os.environ}.
- C{env} is a L{dict}:
- On POSIX: pass the key/value pairs in C{env} as the
complete environment.
- On Windows: update L{os.environ} with the key/value
pairs in the L{dict} before passing it. As a
consequence of U{bug #1640
<http://twistedmatrix.com/trac/ticket/1640>}, passing
keys with empty values in an effort to unset
environment variables I{won't} unset them.
@param path: the path to run the subprocess in - defaults to the
current directory.
@param uid: user ID to run the subprocess as. (Only available on POSIX
systems.)
@param gid: group ID to run the subprocess as. (Only available on
POSIX systems.)
@param usePTY: if true, run this process in a pseudo-terminal.
optionally a tuple of C{(masterfd, slavefd, ttyname)}, in which
case use those file descriptors. (Not available on all systems.)
@param childFDs: A dictionary mapping file descriptors in the new child
process to an integer or to the string 'r' or 'w'.
If the value is an integer, it specifies a file descriptor in the
parent process which will be mapped to a file descriptor (specified
by the key) in the child process. This is useful for things like
inetd and shell-like file redirection.
If it is the string 'r', a pipe will be created and attached to the
child at that file descriptor: the child will be able to write to
that file descriptor and the parent will receive read notification
via the L{IProcessProtocol.childDataReceived} callback. This is
useful for the child's stdout and stderr.
If it is the string 'w', similar setup to the previous case will
occur, with the pipe being readable by the child instead of
writeable. The parent process can write to that file descriptor
using L{IProcessTransport.writeToChild}. This is useful for the
child's stdin.
If childFDs is not passed, the default behaviour is to use a
mapping that opens the usual stdin/stdout/stderr pipes.
@see: L{twisted.internet.protocol.ProcessProtocol}
@return: An object which provides L{IProcessTransport}.
@raise OSError: Raised with errno C{EAGAIN} or C{ENOMEM} if there are
insufficient system resources to create a new process.
Nr+ ) r� r� r� r� r� r� r� r� r� s r- � spawnProcessz IReactorProcess.spawnProcess, r3 r, N)
r' r( r) r
�bytesrC r r
r r rD r� r� r+ r, r- r� r� + s� � �_ �+�_ ��%��*�%�_ � �u�U�C�Z�(�)�_ � �g�f�f�n�-�
.� _ �
�E�3�J� � _ � �
_ � �_ � �_ � �#�u�S�#�X��.�/�_ �
�_ r, r� c
�T � e Zd ZdZdefd�Zdededef dededd f
d
�Z de
d fd �Z y )
� IReactorTimez7
Time methods that a Reactor should implement.
r0 c � � y)zg
Get the current time in seconds.
@return: A number-like object of some sort.
Nr+ r+ r, r- �secondszIReactorTime.seconds� r3 r, �delay�callable.r� �kwargs� IDelayedCallc � � y)a
Call a function later.
@param delay: the number of seconds to wait.
@param callable: the callable object to call later.
@param args: the arguments to call it with.
@param kwargs: the keyword arguments to call it with.
@return: An object which provides L{IDelayedCall} and can be used to
cancel the scheduled call, by calling its C{cancel()} method.
It also may be rescheduled by calling its C{delay()} or
C{reset()} methods.
Nr+ )r� r� r� r� s r- � callLaterzIReactorTime.callLater� r3 r, c � � y)zQ
See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls}
Nr+ r+ r, r- �getDelayedCallsz IReactorTime.getDelayedCalls� r3 r, N) r' r( r) r* r� r� r r r� r� r r� r+ r, r- r� r� � sZ � �� �U� � �� � (��c�� 2� �;A� �MS� � � �" �X�n� 5� r, r� c �P � e Zd ZdZdefd�Zd d�Zdeddfd�Zdeddfd �Zde fd
�Z
y) r� z�
A scheduled call.
There are probably other useful methods we can add to this interface;
suggestions are welcome.
r0 c � � y)zr
Get time when delayed call will happen.
@return: time in seconds since epoch (a float).
Nr+ r+ r, r- �getTimezIDelayedCall.getTime� r3 r, Nc � � y)z�
Cancel the scheduled call.
@raises twisted.internet.error.AlreadyCalled: if the call has already
happened.
@raises twisted.internet.error.AlreadyCancelled: if the call has already
been cancelled.
Nr+ r+ r, r- rH zIDelayedCall.cancel� r3 r, � secondsLaterc � � y)aR
Delay the scheduled call.
@param secondsLater: how many seconds from its current firing time to delay
@raises twisted.internet.error.AlreadyCalled: if the call has already
happened.
@raises twisted.internet.error.AlreadyCancelled: if the call has already
been cancelled.
Nr+ )r� s r- r� zIDelayedCall.delay� r3 r, �secondsFromNowc � � y)a�
Reset the scheduled call's timer.
@param secondsFromNow: how many seconds from now it should fire,
equivalent to C{.cancel()} and then doing another
C{reactor.callLater(secondsLater, ...)}
@raises twisted.internet.error.AlreadyCalled: if the call has already
happened.
@raises twisted.internet.error.AlreadyCancelled: if the call has already
been cancelled.
Nr+ )r� s r- �resetzIDelayedCall.reset� r3 r, c � � y)zx
@return: True if this call is still active, False if it has been
called or cancelled.
Nr+ r+ r, r- �activezIDelayedCall.active� r3 r, r: ) r' r( r) r* r� r� rH r� r� r� r� r+ r, r- r� r� � sJ � �� �U� � �
�E�
�d�
� �e� �� � �D� r, r� c �2 � e Zd ZdZdedef dededdfd�Zy) �IReactorFromThreadsz�
This interface is the set of thread-safe methods which may be invoked on
the reactor from other threads.
@since: 15.4
r� .r� r� r0 Nc � � y)a�
Cause a function to be executed by the reactor thread.
Use this method when you want to run a function in the reactor's thread
from another thread. Calling L{callFromThread} should wake up the main
thread (where L{reactor.run() <IReactorCore.run>} is executing) and run
the given callable in that thread.
If you're writing a multi-threaded application the C{callable}
may need to be thread safe, but this method doesn't require it as such.
If you want to call a function in the next mainloop iteration, but
you're in the same thread, use L{callLater} with a delay of 0.
Nr+ �r� r� r� s r- �callFromThreadz"IReactorFromThreads.callFromThread� r3 r, )r' r( r) r* r r r� r� r+ r, r- r� r� � s5 � �� ��3��8�$� �-3� �?E� �
� r, r� c �2 � e Zd ZdZdedef dededdfd�Zy) �IReactorInThreadsz�
This interface contains the methods exposed by a reactor which will let you
run functions in another thread.
@since: 15.4
r� .r� r� r0 Nc � � y)z}
Run the given callable object in a separate thread, with the given
arguments and keyword arguments.
Nr+ r� s r- � callInThreadz IReactorInThreads.callInThread
r3 r, )r' r( r) r* r r r� r r+ r, r- r r s5 � �� ��3��8�$� �-3� �?E� �
� r, r c �( � e Zd ZdZdd�Zdeddfd�Zy)�IReactorThreadsz}
Dispatch methods to be run in threads.
Internally, this should use a thread pool and dispatch methods to them.
r0 c � � y)zx
Return the threadpool used by L{IReactorInThreads.callInThread}.
Create it first if necessary.
Nr+ r+ r, r- �
getThreadPoolz IReactorThreads.getThreadPool r3 r, �sizeNc � � y)z�
Suggest the size of the internal threadpool used to dispatch functions
passed to L{IReactorInThreads.callInThread}.
Nr+ )r s r- �suggestThreadPoolSizez%IReactorThreads.suggestThreadPoolSize# r3 r, )r0 r# )r' r( r) r* r rD r
r+ r, r- r r s � �� � �C� �D� r, r c �� � e Zd ZdZ ed� Zdedee ddfd�Z dd �Z
dd
�Z dd �Z d e
ddfd
�Zdeddfd�Zdedededef dededef d�Zdeddfd�Zdedef dededee fd�Zy)� IReactorCorez5
Core methods that a Reactor must implement.
zjA C{bool} which is C{True} from I{during startup} to I{during shutdown} and C{False} the rest of the time.r= r> r0 r? c � � y)zc
Return a L{twisted.internet.defer.Deferred} that will resolve
a hostname.
Nr+ rA s r- �resolvezIReactorCore.resolve4 r3 r, Nc � � y)z�
Fire 'startup' System Events, move the reactor to the 'running'
state, then run the main loop until it is stopped with C{stop()} or
C{crash()}.
Nr+ r+ r, r- �runzIReactorCore.run: r3 r, c � � y)z�
Fire 'shutdown' System Events, which will move the reactor to the
'stopped' state and cause C{reactor.run()} to exit.
Nr+ r+ r, r- �stopzIReactorCore.stopA r3 r, c � � y)as
Stop the main loop *immediately*, without firing any system events.
This is named as it is because this is an extremely "rude" thing to do;
it is possible to lose data and put your system in an inconsistent
state by calling this. However, it is necessary, as sometimes a system
can become wedged in a pre-shutdown call.
Nr+ r+ r, r- �crashzIReactorCore.crashG r3 r, r� c � � y)ap
Run the main loop's I/O polling function for a period of time.
This is most useful in applications where the UI is being drawn "as
fast as possible", such as games. All pending L{IDelayedCall}s will
be called.
The reactor must have been started (via the C{run()} method) prior to
any invocations of this method. It must also be stopped manually
after the last call to this method (via the C{stop()} method). This
method is not re-entrant: you must not call it recursively; in
particular, you must not call it while the reactor is running.
Nr+ )r� s r- �iteratezIReactorCore.iterateQ r3 r, � eventTypec � � y)z�
Fire a system-wide event.
System-wide events are things like 'startup', 'shutdown', and
'persist'.
Nr+ )r s r- �fireSystemEventz IReactorCore.fireSystemEvent` r3 r, �phaser� .r� r� c � � y)a%
Add a function to be called when a system event occurs.
Each "system event" in Twisted, such as 'startup', 'shutdown', and
'persist', has 3 phases: 'before', 'during', and 'after' (in that
order, of course). These events will be fired internally by the
Reactor.
An implementor of this interface must only implement those events
described here.
Callbacks registered for the "before" phase may return either None or a
Deferred. The "during" phase will not execute until all of the
Deferreds from the "before" phase have fired.
Once the "during" phase is running, all of the remaining triggers must
execute; their return values must be ignored.
@param phase: a time to call the event -- either the string 'before',
'after', or 'during', describing when to call it
relative to the event's execution.
@param eventType: this is a string describing the type of event.
@param callable: the object to call before shutdown.
@param args: the arguments to call it with.
@param kwargs: the keyword arguments to call it with.
@return: an ID that can be used to remove this call with
removeSystemEventTrigger.
Nr+ )r r r� r� r� s r- �addSystemEventTriggerz"IReactorCore.addSystemEventTriggerh r3 r, � triggerIDc � � y)a�
Removes a trigger added with addSystemEventTrigger.
@param triggerID: a value returned from addSystemEventTrigger.
@raise KeyError: If there is no system event trigger for the given
C{triggerID}.
@raise ValueError: If there is no system event trigger for the given
C{triggerID}.
@raise TypeError: If there is no system event trigger for the given
C{triggerID}.
Nr+ )r s r- �removeSystemEventTriggerz%IReactorCore.removeSystemEventTrigger� r3 r, c � � y)a
Call a function when the reactor is running.
If the reactor has not started, the callable will be scheduled
to run when it does start. Otherwise, the callable will be invoked
immediately.
@param callable: the callable object to call later.
@param args: the arguments to call it with.
@param kwargs: the keyword arguments to call it with.
@return: None if the callable was invoked, otherwise a system
event id for the scheduled call.
Nr+ r� s r- �callWhenRunningz IReactorCore.callWhenRunning� r3 r, r: )r' r( r) r* r �runningrC r rD r r r r r� r r r r r� r r r
r! r+ r, r- r r * s� � �� � @��G�
�c� �H�S�M� �o� � � � �
�u�
��
� �3� �4� �# ��# ��# � �3��8�$�# � � # �
� # �
�
# �J �C� �D� � ��3��8�$� �-3� �?E� � �#� � r, r c � � e Zd ZdZdedefd�Zy)�IReactorPluggableResolvera
An L{IReactorPluggableResolver} is a reactor which can be customized with
an L{IResolverSimple}. This is a fairly limited interface, that supports
only IPv4; you should use L{IReactorPluggableNameResolver} instead.
@see: L{IReactorPluggableNameResolver}
�resolverr0 c � � y)z�
Set the internal resolver to use to for name lookups.
@param resolver: The new resolver to use.
@return: The previously installed resolver.
Nr+ �r% s r- �installResolverz)IReactorPluggableResolver.installResolver� r3 r, N)r' r( r) r* r< r( r+ r, r- r$ r$ � s � �� �/� �o� r, r$ c �0 � e Zd ZdZ ed� Zdedefd�Zy)� IReactorPluggableNameResolverzx
An L{IReactorPluggableNameResolver} is a reactor whose name resolver can be
set to a user-supplied object.
zw
Read-only attribute; the resolver installed with L{installResolver}.
An L{IHostnameResolver}.
r% r0 c � � y)z�
Set the internal resolver to use for name lookups.
@param resolver: The new resolver to use.
@return: The previously installed resolver.
Nr+ r' s r- �installNameResolverz1IReactorPluggableNameResolver.installNameResolver� r3 r, N)r' r( r) r* r � nameResolverrT r, r+ r, r- r* r* � s- � ��
� ��L� �&7� �<M� r, r* c � � e Zd ZdZdd�Zdd�Zy)�IReactorDaemonizea�
A reactor which provides hooks that need to be called before and after
daemonization.
Notes:
- This interface SHOULD NOT be called by applications.
- This interface should only be implemented by reactors as a workaround
(in particular, it's implemented currently only by kqueue()).
For details please see the comments on ticket #1918.
Nc � � y)z�
Hook to be called immediately before daemonization. No reactor methods
may be called until L{afterDaemonize} is called.
Nr+ r+ r, r- �beforeDaemonizez!IReactorDaemonize.beforeDaemonize� r3 r, c � � y)z�
Hook to be called immediately after daemonization. This may only be
called after L{beforeDaemonize} had been called previously.
Nr+ r+ r, r- �afterDaemonizez IReactorDaemonize.afterDaemonize� r3 r, r: )r' r( r) r* r1 r3 r+ r, r- r/ r/ � s � � � � r, r/ c �l � e Zd ZdZdd�Zdd�Zdd�Zdd �Zdee d
fd �Z
ded fd �Z ded fd
�Z y)�
IReactorFDSetz�
Implement me to be able to use L{IFileDescriptor} type resources.
This assumes that your main-loop uses UNIX-style numeric file descriptors
(or at least similarly opaque IDs returned from a .fileno() method)
�IReadDescriptorr0 Nc � � y)a
I add reader to the set of file descriptors to get read events for.
@param reader: An L{IReadDescriptor} provider that will be checked for
read events until it is removed from the reactor with
L{removeReader}.
Nr+ ��readers r- � addReaderzIReactorFDSet.addReader� r3 r, �IWriteDescriptorc � � y)a
I add writer to the set of file descriptors to get write events for.
@param writer: An L{IWriteDescriptor} provider that will be checked for
write events until it is removed from the reactor with
L{removeWriter}.
Nr+ ��writers r- � addWriterzIReactorFDSet.addWriter r3 r, c � � y)zG
Removes an object previously added with L{addReader}.
Nr+ r8 s r- � removeReaderzIReactorFDSet.removeReader r3 r, c � � y)zG
Removes an object previously added with L{addWriter}.
Nr+ r= s r- � removeWriterzIReactorFDSet.removeWriter r3 r, )r6 r; c � � y)z�
Remove all readers and writers.
Should not remove reactor internal reactor connections (like a waker).
@return: A list of L{IReadDescriptor} and L{IWriteDescriptor} providers
which were removed.
Nr+ r+ r, r- � removeAllzIReactorFDSet.removeAll r3 r, c � � y)z�
Return the list of file descriptors currently monitored for input
events by the reactor.
@return: the list of file descriptors monitored for input events.
Nr+ r+ r, r- �
getReaderszIReactorFDSet.getReaders r3 r, c � � y)z�
Return the list file descriptors currently monitored for output events
by the reactor.
@return: the list of file descriptors monitored for output events.
Nr+ r+ r, r- �
getWriterszIReactorFDSet.getWriters' r3 r, )r9 r6 r0 N)r> r; r0 N)
r' r( r) r* r: r? rA rC r r
rE rG rI r+ r, r- r5 r5 � sV � �� � � �
�
�t�E�"G� H�I� � �� .�/� � �� /�0� r, r5 c �6 � e Zd ZdZdd�Zded fd�Zdefd�Zy) r� z
A listening port.
r0 Nc � � y)a
Start listening on this port.
@raise CannotListenError: If it cannot listen on this port (e.g., it is
a TCP port and it cannot bind to the required
port number).
Nr+ r+ r, r- �startListeningz IListeningPort.startListening5 r3 r, r c � � y)z�
Stop listening on this port.
If it does not complete immediately, will return Deferred that fires
upon completion.
Nr+ r+ r, r- �
stopListeningz IListeningPort.stopListening> r3 r, c � � y)zj
Get the host that this port is listening for.
@return: An L{IAddress} provider.
Nr+ r+ r, r- �getHostzIListeningPort.getHostF r3 r, r: ) r' r( r) r* rL r
rN r% rP r+ r, r- r� r� 0 s) � �� � �8�J�/� � �X� r, r� c � � e Zd ZdZdefd�Zy)�ILoggingContextz^
Give context information that will be used to log events generated by
this item.
r0 c � � y)zQ
@return: Prefix used during log formatting to indicate context.
Nr+ r+ r, r- � logPrefixzILoggingContext.logPrefixT r3 r, N)r' r( r) r* rC rT r+ r, r- rR rR N s � ��
�s� r, rR c �, � e Zd ZdZdefd�Zdeddfd�Zy)�IFileDescriptorzI
An interface representing a UNIX-style numeric file descriptor.
r0 c � � y)aY
@return: The platform-specified representation of a file descriptor
number. Or C{-1} if the descriptor no longer has a valid file
descriptor number associated with it. As long as the descriptor
is valid, calls to this method on a particular instance must
return the same value.
Nr+ r+ r, r- �filenozIFileDescriptor.fileno_ r3 r, �reasonNc � � y)a�
Called when the connection was lost.
This is called when the connection on a selectable object has been
lost. It will be called whether the connection was closed explicitly,
an exception occurred in an event handler, or the other end of the
connection closed it first.
See also L{IHalfCloseableDescriptor} if your descriptor wants to be
notified separately of the two halves of the connection being closed.
@param reason: A failure instance indicating the reason why the
connection was lost. L{error.ConnectionLost} and
L{error.ConnectionDone} are of special note, but the
failure may be of other classes as well.
Nr+ �rY s r- �connectionLostz IFileDescriptor.connectionLosth r3 r, )r' r( r) r* r� rX r r\ r+ r, r- rV rV Z s& � �� �F� � �w� �4� r, rV c �" � e Zd ZdZdee fd�Zy)r6 zz
An L{IFileDescriptor} that can read.
This interface is generally used in conjunction with L{IReactorFDSet}.
r0 c � � y)z�
Some data is available for reading on your descriptor.
@return: If an error is encountered which causes the descriptor to
no longer be valid, a L{Failure} should be returned. Otherwise,
L{None}.
Nr+ r+ r, r- �doReadzIReadDescriptor.doRead� r3 r, N)r' r( r) r* r
r r_ r+ r, r- r6 r6 { s � �� �H�W�%� r, r6 c �" � e Zd ZdZdee fd�Zy)r; z{
An L{IFileDescriptor} that can write.
This interface is generally used in conjunction with L{IReactorFDSet}.
r0 c � � y)z�
Some data can be written to your descriptor.
@return: If an error is encountered which causes the descriptor to
no longer be valid, a L{Failure} should be returned. Otherwise,
L{None}.
Nr+ r+ r, r- �doWritezIWriteDescriptor.doWrite� r3 r, N)r' r( r) r* r
r rb r+ r, r- r; r; � s � �� �X�g�&� r, r; c � � e Zd ZdZy)�IReadWriteDescriptorz=
An L{IFileDescriptor} that can both read and write.
Nr& r+ r, r- rd rd � s � �r, rd c �0 � e Zd ZdZdeddfd�Zdeddfd�Zy)�IHalfCloseableDescriptorz/
A descriptor that can be half-closed.
rY r0 Nc � � y)z6
Indicates write connection was lost.
Nr+ r[ s r- �writeConnectionLostz,IHalfCloseableDescriptor.writeConnectionLost� r3 r, c � � y)z5
Indicates read connection was lost.
Nr+ r[ s r- �readConnectionLostz+IHalfCloseableDescriptor.readConnectionLost� r3 r, )r' r( r) r* r rh rj r+ r, r- rf rf � s- � �� �G� �� �
�7� �t� r, rf c � � e Zd ZdZdefd�Zy)�
ISystemHandlez?
An object that wraps a networking OS-specific handle.
r0 c � � y)ab
Return a system- and reactor-specific handle.
This might be a socket.socket() object, or some other type of
object, depending on which reactor is being used. Use and
manipulate at your own risk.
This might be used in cases where you want to set specific
options not exposed by the Twisted APIs.
Nr+ r+ r, r- � getHandlezISystemHandle.getHandle� r3 r, N)r' r( r) r* r� rn r+ r, r- rl rl � s � ��
�v�
r, rl c �< � e Zd ZdZdddeddfd�Zd d�Zd eddfd
�Zy) � IConsumerz3
A consumer consumes data from a producer.
�producer� IProducer� streamingr0 Nc � � y)a�
Register to receive data from a producer.
This sets self to be a consumer for a producer. When this object runs
out of data (as when a send(2) call on a socket succeeds in moving the
last data from a userspace buffer into a kernelspace buffer), it will
ask the producer to resumeProducing().
For L{IPullProducer} providers, C{resumeProducing} will be called once
each time data is required.
For L{IPushProducer} providers, C{pauseProducing} will be called
whenever the write buffer fills up and C{resumeProducing} will only be
called when it empties. The consumer will only call C{resumeProducing}
to balance a previous C{pauseProducing} call; the producer is assumed
to start in an un-paused state.
@param streaming: C{True} if C{producer} provides L{IPushProducer},
C{False} if C{producer} provides L{IPullProducer}.
@raise RuntimeError: If a producer is already registered.
Nr+ )rq rs s r- �registerProducerzIConsumer.registerProducer� r3 r, c � � y)zM
Stop consuming data from a producer, without disconnecting.
Nr+ r+ r, r- �unregisterProducerz IConsumer.unregisterProducer� r3 r, �datac � � y)a@
The producer will write data by calling this method.
The implementation must be non-blocking and perform whatever
buffering is necessary. If the producer has provided enough data
for now and it is a L{IPushProducer}, the consumer may call its
C{pauseProducing} method.
Nr+ �rx s r- �writezIConsumer.write� r3 r, r: ) r' r( r) r* r� ru rw r� r{ r+ r, r- rp rp � s9 � �� �;� �4� �D� �0 �
�E� �d� r, rp c � � e Zd ZdZdd�Zy)rr z�
A producer produces data for a consumer.
Typically producing is done by calling the C{write} method of a class
implementing L{IConsumer}.
Nc � � y)z�
Stop producing data.
This tells a producer that its consumer has died, so it must stop
producing data for good.
Nr+ r+ r, r- �
stopProducingzIProducer.stopProducing� r3 r, r: )r' r( r) r* r~ r+ r, r- rr rr � s � �� r, rr c � � e Zd ZdZdd�Zdd�Zy)�
IPushProducera^
A push producer, also known as a streaming producer is expected to
produce (write to this consumer) data on a continuous basis, unless
it has been paused. A paused push producer will resume producing
after its C{resumeProducing()} method is called. For a push producer
which is not pauseable, these functions may be noops.
Nc � � y)z�
Pause producing data.
Tells a producer that it has produced too much data to process for
the time being, and to stop until C{resumeProducing()} is called.
Nr+ r+ r, r- �pauseProducingz IPushProducer.pauseProducing r3 r, c � � y)z�
Resume producing data.
This tells a producer to re-add itself to the main loop and produce
more data for its consumer.
Nr+ r+ r, r- �resumeProducingz IPushProducer.resumeProducing r3 r, r: )r' r( r) r* r� r� r+ r, r- r� r� s � �� � r, r� c � � e Zd ZdZdd�Zy)�
IPullProducerz�
A pull producer, also known as a non-streaming producer, is
expected to produce data each time L{resumeProducing()} is called.
Nc � � y)a�
Produce data for the consumer a single time.
This tells a producer to produce data for the consumer once
(not repeatedly, once only). Typically this will be done
by calling the consumer's C{write} method a single time with
produced data. The producer should produce data before returning
from C{resumeProducing()}, that is, it should not schedule a deferred
write.
Nr+ r+ r, r- r� z IPullProducer.resumeProducing# r3 r, r: )r' r( r) r* r� r+ r, r- r� r� s � ��
r, r� c �< � e Zd Zdeddfd�Zdeddfd�Zd d�Zd
d�Zy) � IProtocolrx r0 Nc � � y)a2
Called whenever data is received.
Use this method to translate to a higher-level message. Usually, some
callback will be made upon the receipt of each complete protocol
message.
Please keep in mind that you will probably need to buffer some data
as partial (or multiple) protocol messages may be received! We
recommend that unit tests for protocols call through to this method
with differing chunk sizes, down to one byte at a time.
@param data: bytes of indeterminate length
Nr+ rz s r- � dataReceivedzIProtocol.dataReceived1 r3 r, rY c � � y)as
Called when the connection is shut down.
Clear any circular references here, and any external references
to this Protocol. The connection has been closed. The C{reason}
Failure wraps a L{twisted.internet.error.ConnectionDone} or
L{twisted.internet.error.ConnectionLost} instance (or a subclass
of one of those).
Nr+ r[ s r- r\ zIProtocol.connectionLostA r3 r, c � � y)z@
Make a connection to a transport and a server.
Nr+ )� transports r- �makeConnectionzIProtocol.makeConnectionL r3 r, c � � y)a�
Called when a connection is made.
This may be considered the initializer of the protocol, because
it is called when the connection is completed. For clients,
this is called once the connection to the server has been
established; for servers, this is called after an accept() call
stops blocking and a socket has been received. If you need to
send any greeting or initial message, do it here.
Nr+ r+ r, r- �connectionMadezIProtocol.connectionMadeQ r3 r, )r� �
ITransportr0 Nr: ) r' r( r) r� r� r r\ r� r� r+ r, r- r� r� 0 s2 � � �5� �T� � �w� �4� � �
r, r� c �\ � e Zd ZdZd d�Zdededdfd�Zdeddfd�Zd e ddfd
�Z
d e ddfd �Z y)
r� z7
Interface for process-related event handlers.
r0 Nc � � y)z�
Called when the process has been created.
@param process: An object representing the process which has been
created and associated with this protocol.
Nr+ )�processs r- r� z IProcessProtocol.makeConnectionc r3 r, �childFDrx c � � y)z�
Called when data arrives from the child process.
@param childFD: The file descriptor from which the data was
received.
@param data: The data read from the child's file descriptor.
Nr+ �r� rx s r- �childDataReceivedz"IProcessProtocol.childDataReceivedk r3 r, c � � y)z�
Called when a file descriptor associated with the child process is
closed.
@param childFD: The file descriptor which was closed.
Nr+ )r� s r- �childConnectionLostz$IProcessProtocol.childConnectionLostt r3 r, rY c � � y)aI
Called when the child process exits.
@param reason: A failure giving the reason the child process
terminated. The type of exception for this failure is either
L{twisted.internet.error.ProcessDone} or
L{twisted.internet.error.ProcessTerminated}.
@since: 8.2
Nr+ r[ s r- �
processExitedz IProcessProtocol.processExited| r3 r, c � � y)ay
Called when the child process exits and all file descriptors associated
with it have been closed.
@param reason: A failure giving the reason the child process
terminated. The type of exception for this failure is either
L{twisted.internet.error.ProcessDone} or
L{twisted.internet.error.ProcessTerminated}.
Nr+ r[ s r- � processEndedz IProcessProtocol.processEnded� r3 r, )r� r� r0 N) r' r( r) r* r� rD r� r� r� r r� r� r+ r, r- r� r� ^ s_ � �� � �3� �e� �� � �S� �T� �
�g�
�$�
� �W� �� r, r� c � � e Zd ZdZdd�Zdd�Zy)�IHalfCloseableProtocolaA
Implemented to indicate they want notification of half-closes.
TCP supports the notion of half-closing the connection, e.g.
closing the write side but still not stopping reading. A protocol
that implements this interface will be notified of such events,
instead of having connectionLost called.
Nc � � y)a=
Notification of the read connection being closed.
This indicates peer did half-close of write side. It is now
the responsibility of the this protocol to call
loseConnection(). In addition, the protocol MUST make sure a
reference to it still exists (i.e. by doing a callLater with
one of its methods, etc.) as the reactor will only have a
reference to it if it is writing.
If the protocol does not do so, it might get garbage collected
without the connectionLost method ever being called.
Nr+ r+ r, r- rj z)IHalfCloseableProtocol.readConnectionLost� r3 r, c � � y)z�
Notification of the write connection being closed.
This will never be called for TCP connections as TCP does not
support notification of this type of half-close.
Nr+ r+ r, r- rh z*IHalfCloseableProtocol.writeConnectionLost� r3 r, r: )r' r( r) r* rj rh r+ r, r- r� r� � s � ��
� r, r� c � � e Zd ZdZdd�Zy)�IHandshakeListeneraC
An interface implemented by a L{IProtocol} to indicate that it would like
to be notified when TLS handshakes complete when run over a TLS-based
transport.
This interface is only guaranteed to be called when run over a TLS-based
transport: non TLS-based transports will not respect this interface.
Nc � � y)ax
Notification of the TLS handshake being completed.
This notification fires when OpenSSL has completed the TLS handshake.
At this point the TLS connection is established, and the protocol can
interrogate its transport (usually an L{ISSLTransport}) for details of
the TLS connection.
This notification *also* fires whenever the TLS session is
renegotiated. As a result, protocols that have certain minimum security
requirements should implement this interface to ensure that they are
able to re-evaluate the security of the TLS session if it changes.
Nr+ r+ r, r- �handshakeCompletedz%IHandshakeListener.handshakeCompleted� r3 r, r: )r' r( r) r* r� r+ r, r- r� r� � s � ��
r, r� c � � e Zd ZdZdeddfd�Zy)�IFileDescriptorReceiverz�
Protocols may implement L{IFileDescriptorReceiver} to receive file
descriptors sent to them. This is useful in conjunction with
L{IUNIXTransport}, which allows file descriptors to be sent between
processes on a single host.
�
descriptorr0 Nc � � y)z�
Called when a file descriptor is received over the connection.
@param descriptor: The descriptor which was received.
@return: L{None}
Nr+ �r� s r- �fileDescriptorReceivedz.IFileDescriptorReceiver.fileDescriptorReceived� r3 r, )r' r( r) r* rD r� r+ r, r- r� r� � s � �� �3� �4� r, r� c �6 � e Zd ZdZdedee fd�Zdd�Zdd�Z y) �IProtocolFactoryz+
Interface for protocol factories.
�addrr0 c � � y)a
Called when a connection has been established to addr.
If None is returned, the connection is assumed to have been refused,
and the Port will close the connection.
@param addr: The address of the newly-established connection
@return: None if the connection was refused, otherwise an object
providing L{IProtocol}.
Nr+ �r� s r- �
buildProtocolz IProtocolFactory.buildProtocol� r3 r, Nc � � y)zM
Called every time this is connected to a Port or Connector.
Nr+ r+ r, r- �doStartzIProtocolFactory.doStart� r3 r, c � � y)zQ
Called every time this is unconnected from a Port or Connector.
Nr+ r+ r, r- �doStopzIProtocolFactory.doStop� r3 r, r: )
r' r( r) r* r% r
r� r� r� r� r+ r, r- r� r� � s) � �� �H� ��)�)<� � �
r, r� c �V � e Zd ZdZdeddfd�Zdee ddfd�Zd
d�Zde fd�Z
de fd �Z y) r� a�
I am a transport for bytes.
I represent (and wrap) the physical connection and synchronicity
of the framework which is talking to the network. I make no
representations about whether calls to me will happen immediately
or require returning to a control loop, or whether they will happen
in the same or another thread. Consider methods of this class
(aside from getPeer) to be 'thrown over the wall', to happen at some
indeterminate time.
rx r0 Nc � � y)aH
Write some data to the physical connection, in sequence, in a
non-blocking fashion.
If possible, make sure that it is all written. No data will
ever be lost, although (obviously) the connection may be closed
before it all gets through.
@param data: The data to write.
Nr+ rz s r- r{ zITransport.write r3 r, c � � y)a
Write an iterable of byte strings to the physical connection.
If possible, make sure that all of the data is written to
the socket at once, without first copying it all into a
single byte string.
@param data: The data to write.
Nr+ rz s r- �
writeSequencezITransport.writeSequence r3 r, c � � y)z�
Close my connection, after writing all pending data.
Note that if there is a registered producer on a transport it
will not be closed until the producer has been unregistered.
Nr+ r+ r, r- �loseConnectionzITransport.loseConnection# r3 r, c � � y)ah
Get the remote address of this connection.
Treat this method with caution. It is the unfortunate result of the
CGI and Jabber standards, but should not be considered reliable for
the usual host of reasons; port forwarding, proxying, firewalls, IP
masquerading, etc.
@return: An L{IAddress} provider.
Nr+ r+ r, r- �getPeerzITransport.getPeer+ r3 r, c � � y)z�
Similar to getPeer, but returns an address describing this side of the
connection.
@return: An L{IAddress} provider.
Nr+ r+ r, r- rP zITransport.getHost7 r3 r, r: ) r' r( r) r* r� r{ r r� r� r% r� rP r+ r, r- r� r� � sN � �
�
�E�
�d�
� �H�U�O� �� � �
�X�
� �X� r, r� c �| � e Zd ZdZdd�Zdd�Zdefd�Zdeddfd�Zdefd �Z deddfd
�Z
de d fd �Z de d fd
�Z
y)�
ITCPTransportz
A TCP based transport.
r0 Nc � � y)aq
Half-close the write side of a TCP connection.
If the protocol instance this is attached to provides
IHalfCloseableProtocol, it will get notified when the operation is
done. When closing write connection, as with loseConnection this will
only happen when buffer has emptied and there is no registered
producer.
Nr+ r+ r, r- �loseWriteConnectionz!ITCPTransport.loseWriteConnectionE r3 r, c � � y)z�
Close the connection abruptly.
Discards any buffered data, stops any registered producer,
and, if possible, notifies the other end of the unclean
closure.
@since: 11.1
Nr+ r+ r, r- �abortConnectionz ITCPTransport.abortConnectionP r3 r, c � � y)z6
Return if C{TCP_NODELAY} is enabled.
Nr+ r+ r, r- �
getTcpNoDelayzITCPTransport.getTcpNoDelay[ r3 r, �enabledc � � y)z�
Enable/disable C{TCP_NODELAY}.
Enabling C{TCP_NODELAY} turns off Nagle's algorithm. Small packets are
sent sooner, possibly at the expense of overall throughput.
Nr+ �r� s r- �
setTcpNoDelayzITCPTransport.setTcpNoDelay` r3 r, c � � y)z7
Return if C{SO_KEEPALIVE} is enabled.
Nr+ r+ r, r- �getTcpKeepAlivez ITCPTransport.getTcpKeepAliveh r3 r, c � � y)a
Enable/disable C{SO_KEEPALIVE}.
Enabling C{SO_KEEPALIVE} sends packets periodically when the connection
is otherwise idle, usually once every two hours. They are intended
to allow detection of lost peers in a non-infinite amount of time.
Nr+ r� s r- �setTcpKeepAlivez ITCPTransport.setTcpKeepAlivem r3 r, �r r c � � y�z;
Returns L{IPv4Address} or L{IPv6Address}.
Nr+ r+ r, r- rP zITCPTransport.getHostv r3 r, c � � yr� r+ r+ r, r- r� zITCPTransport.getPeer{ r3 r, r: )r' r( r) r* r� r� r� r� r� r� r� r
rP r� r+ r, r- r� r� @ ss � �� � � �4� �
�t� �� � �T� �
�� �$� � �U�7�8� �
�U�7�8� r, r� c � � e Zd ZdZdeddfd�Zy)�IUNIXTransportz@
Transport for stream-oriented unix domain connections.
r� r0 Nc � � y)ax
Send a duplicate of this (file, socket, pipe, etc) descriptor to the
other end of this connection.
The send is non-blocking and will be queued if it cannot be performed
immediately. The send will be processed in order with respect to other
C{sendFileDescriptor} calls on this transport, but not necessarily with
respect to C{write} calls on this transport. The send can only be
processed if there are also bytes in the normal connection-oriented send
buffer (ie, you must call C{write} at least as many times as you call
C{sendFileDescriptor}).
@param descriptor: An C{int} giving a valid file descriptor in this
process. Note that a I{file descriptor} may actually refer to a
socket, a pipe, or anything else POSIX tries to treat in the same
way as a file.
Nr+ r� s r- �sendFileDescriptorz!IUNIXTransport.sendFileDescriptor� r3 r, )r' r( r) r* rD r� r+ r, r- r� r� � s � �� �s� �t� r, r� c � � e Zd ZdZ dd�Zy)� IOpenSSLServerConnectionCreatoraX
A provider of L{IOpenSSLServerConnectionCreator} can create
L{OpenSSL.SSL.Connection} objects for TLS servers.
@see: L{twisted.internet.ssl}
@note: Creating OpenSSL connection objects is subtle, error-prone, and
security-critical. Before implementing this interface yourself,
consider using L{twisted.internet.ssl.CertificateOptions} as your
C{contextFactory}. (For historical reasons, that class does not
actually I{implement} this interface; nevertheless it is usable in all
Twisted APIs which require a provider of this interface.)
c � � y)z�
Create a connection for the given server protocol.
@return: an OpenSSL connection object configured appropriately for the
given Twisted protocol.
Nr+ �� tlsProtocols r- �serverConnectionForTLSz6IOpenSSLServerConnectionCreator.serverConnectionForTLS� r3 r, N�r� r! r0 �OpenSSLConnection)r' r( r) r* r� r+ r, r- r� r� � s � � � �+� � � r, r� c � � e Zd ZdZ dd�Zy)� IOpenSSLClientConnectionCreatora�
A provider of L{IOpenSSLClientConnectionCreator} can create
L{OpenSSL.SSL.Connection} objects for TLS clients.
@see: L{twisted.internet.ssl}
@note: Creating OpenSSL connection objects is subtle, error-prone, and
security-critical. Before implementing this interface yourself,
consider using L{twisted.internet.ssl.optionsForClientTLS} as your
C{contextFactory}.
c � � y)z�
Create a connection for the given client protocol.
@param tlsProtocol: the client protocol making the request.
@return: an OpenSSL connection object configured appropriately for the
given Twisted protocol.
Nr+ r� s r- �clientConnectionForTLSz6IOpenSSLClientConnectionCreator.clientConnectionForTLS� r3 r, Nr� )r' r( r) r* r� r+ r, r- r� r� � s � �
�
�+�
� �
r, r� c �" � e Zd ZdZdee fd�Zy)�IProtocolNegotiationFactoryaL
A provider of L{IProtocolNegotiationFactory} can provide information about
the various protocols that the factory can create implementations of. This
can be used, for example, to provide protocol names for Next Protocol
Negotiation and Application Layer Protocol Negotiation.
@see: L{twisted.internet.ssl}
r0 c � � y)z�
Returns a list of protocols that can be spoken by the connection
factory in the form of ALPN tokens, as laid out in the IANA registry
for ALPN tokens.
@return: a list of ALPN tokens in order of preference.
Nr+ r+ r, r- �acceptableProtocolsz/IProtocolNegotiationFactory.acceptableProtocols� r3 r, N)r' r( r) r* r r� r� r+ r, r- r� r� � s � �� ��e�� r, r� c � � e Zd ZdZdd�Zy)r� a5
A provider of L{IOpenSSLContextFactory} is capable of generating
L{OpenSSL.SSL.Context} classes suitable for configuring TLS on a
connection. A provider will store enough state to be able to generate these
contexts as needed for individual connections.
@see: L{twisted.internet.ssl}
c � � y)z�
Returns a TLS context object, suitable for securing a TLS connection.
This context object will be appropriately customized for the connection
based on the state in this object.
@return: A TLS context object.
Nr+ r+ r, r- �
getContextz!IOpenSSLContextFactory.getContext� r3 r, N)r0 �OpenSSLContext)r' r( r) r* r� r+ r, r- r� r� � s � �� r, r� c �* � e Zd ZdZdeeef ddfd�Zy)�
ITLSTransportz�
A TCP transport that supports switching to TLS midstream.
Once TLS mode is started the transport will implement L{ISSLTransport}.
r� r0 Nc � � y)a�
Initiate TLS negotiation.
@param contextFactory: An object which creates appropriately configured
TLS connections.
For clients, use L{twisted.internet.ssl.optionsForClientTLS}; for
servers, use L{twisted.internet.ssl.CertificateOptions}.
@type contextFactory: L{IOpenSSLClientConnectionCreator} or
L{IOpenSSLServerConnectionCreator}, depending on whether this
L{ITLSTransport} is a server or not. If the appropriate interface
is not provided by the value given for C{contextFactory}, it must
be an implementor of L{IOpenSSLContextFactory}.
Nr+ )r� s r- �startTLSzITLSTransport.startTLS� r3 r, )r' r( r) r* r
r� r� r� r+ r, r- r� r� � s, � �� � � +�-L� L�
� �
� r, r� c � � e Zd ZdZdefd�Zy)�
ISSLTransportz$
A SSL/TLS based transport.
r0 c � � y)zD
Return an object with the peer's certificate info.
Nr+ r+ r, r- �getPeerCertificatez ISSLTransport.getPeerCertificate r3 r, N)r' r( r) r* r� r� r+ r, r- r� r� s � �� �� r, r� c � � e Zd ZdZ ed� Zy)� INegotiatedz�
A TLS based transport that supports using ALPN/NPN to negotiate the
protocol to be used inside the encrypted tunnel.
aC
The protocol selected to be spoken using ALPN/NPN. The result from ALPN
is preferred to the result from NPN if both were used. If the remote
peer does not support ALPN or NPN, or neither NPN or ALPN are available
on this machine, will be L{None}. Otherwise, will be the name of the
selected protocol as C{bytes}. Note that until the handshake has
completed this property may incorrectly return L{None}: wait until data
has been received before trusting it (see
https://twistedmatrix.com/trac/ticket/6024).
N)r' r( r) r* r �negotiatedProtocolr+ r, r- r� r� s � ��
#� � �r, r� c � � e Zd ZdZ ed� Zy)�ICipherz
A TLS cipher.
z5The fully qualified name of the cipher in L{unicode}.N)r' r( r) r* r �fullNamer+ r, r- r� r� 2 s � �� �P�Q�Hr, r� c �, � e Zd ZdZdee dee fd�Zy)�IAcceptableCiphersz9
A list of acceptable ciphers for a TLS context.
�availableCiphersr0 c � � y)a�
Choose which ciphers to allow to be negotiated on a TLS connection.
@param availableCiphers: A L{tuple} of L{ICipher} which gives the names
of all ciphers supported by the TLS implementation in use.
@return: A L{tuple} of L{ICipher} which represents the ciphers
which may be negotiated on the TLS connection. The result is
ordered by preference with more preferred ciphers appearing
earlier.
Nr+ )r� s r- �
selectCiphersz IAcceptableCiphers.selectCiphers? r3 r, N)r' r( r) r* r r� r� r+ r, r- r� r� : s" � �� ��g�� �5��>� r, r� c �~ � e Zd ZdZ ed� Zdd�Zdd�Zdd�Zde ddfd �Z
d
e d e ddfd �Z dd
�Z
deee f ddfd�Zy)r� z
A process transport.
z�From before L{IProcessProtocol.makeConnection} is called to before L{IProcessProtocol.processEnded} is called, C{pid} is an L{int} giving the platform process ID of this process. C{pid} is L{None} at all other times.r0 Nc � � y)zB
Close stdin after all data has been written out.
Nr+ r+ r, r- �
closeStdinz IProcessTransport.closeStdinY r3 r, c � � y)z
Close stdout.
Nr+ r+ r, r- � closeStdoutz IProcessTransport.closeStdout^ r3 r, c � � y)z
Close stderr.
Nr+ r+ r, r- � closeStderrz IProcessTransport.closeStderrc r3 r, r� c � � y)z�
Close a file descriptor which is connected to the child process, identified
by its FD in the child process.
Nr+ r� s r- � closeChildFDz IProcessTransport.closeChildFDh r3 r, r� rx c � � y)a�
Similar to L{ITransport.write} but also allows the file descriptor in
the child process which will receive the bytes to be specified.
@param childFD: The file descriptor to which to write.
@param data: The bytes to write.
@raise KeyError: If C{childFD} is not a file descriptor that was mapped
in the child when L{IReactorProcess.spawnProcess} was used to create
it.
Nr+ r� s r- � writeToChildz IProcessTransport.writeToChildn r3 r, c � � y)z1
Close stdin, stderr and stdout.
Nr+ r+ r, r- r� z IProcessTransport.loseConnection{ r3 r, �signalIDc � � y)a*
Send a signal to the process.
@param signalID: can be
- one of C{"KILL"}, C{"TERM"}, or C{"INT"}.
These will be implemented in a
cross-platform manner, and so should be used
if possible.
- an integer, where it represents a POSIX
signal ID.
@raise twisted.internet.error.ProcessExitedAlready: If the process has
already exited.
@raise OSError: If the C{os.kill} call fails with an errno different
from C{ESRCH}.
Nr+ )r s r- �
signalProcessz IProcessTransport.signalProcess� r3 r, r: )r' r( r) r* r �pidr r r rD r r� r
r� r
rC r r+ r, r- r� r� M st � �� � � �C� �
�
�
�� �� � �c� �� �4� � �
��c�3�h�� �D� r, r� c �@ � e Zd ZdZdedefd�Zdeddfd�Zdeddfd�Zy) �IServiceCollectionzF
An object which provides access to a collection of services.
� serviceNamer0 c � � y)z�
Retrieve the named service from this application.
Raise a C{KeyError} if there is no such service name.
Nr+ )r s r- �getServiceNamedz"IServiceCollection.getServiceNamed� r3 r, �serviceNc � � y)z3
Add a service to this collection.
Nr+ �r s r- �
addServicez IServiceCollection.addService� r3 r, c � � y)z8
Remove a service from this collection.
Nr+ r s r- �
removeServicez IServiceCollection.removeService� r3 r, ) r' r( r) r* rC r� r r r r+ r, r- r r � s@ � �� �S� �V� � �F� �t� �
�v� �$� r, r c � � e Zd ZdZdedeeeef ddfd�Z dededdfd �Z
de d
fd �Z ded fd
�Z
deddfd�Zdefd�Zy)�
IUDPTransportz.
Transport for UDP DatagramProtocols.
�packetr� r0 Nc � � y)a`
Write packet to given address.
@param addr: a tuple of (ip, port). For connected transports must
be the address the transport is connected to, or None.
In non-connected mode this is mandatory.
@raise twisted.internet.error.MessageLengthError: C{packet} was too
long.
Nr+ �r r� s r- r{ zIUDPTransport.write� r3 r, r� r� c � � y)a�
Connect the transport to an address.
This changes it to connected mode. Datagrams can only be sent to
this address, and will only be received from this address. In addition
the protocol's connectionRefused method might get called if destination
is not receiving datagrams.
@param host: an IP address, not a domain name ('127.0.0.1', not 'localhost')
@param port: port to connect to.
Nr+ )r� r� s r- r7 zIUDPTransport.connect� r3 r, r� c � � y)zk
Get this port's host address.
@return: an address describing the listening port.
Nr+ r+ r, r- rP zIUDPTransport.getHost� r3 r, r c � � y)z�
Stop listening on this port.
If it does not complete immediately, will return L{Deferred} that fires
upon completion.
Nr+ r+ r, r- rN zIUDPTransport.stopListening� r3 r, r� c � � y)zo
Set whether this port may broadcast.
@param enabled: Whether the port may broadcast.
Nr+ r� s r- �setBroadcastAllowedz!IUDPTransport.setBroadcastAllowed� r3 r, c � � y)z{
Checks if broadcast is currently allowed on this port.
@return: Whether this port may broadcast.
Nr+ r+ r, r- �getBroadcastAllowedz!IUDPTransport.getBroadcastAllowed� r3 r, )r' r( r) r* r� r
r rC rD r{ r7 r
rP rN r� r$ r& r+ r, r- r r � s� � ��
�e�
�8�E�#�s�(�O�#<�
��
� �c� �� �� � �U�7�8� � �8�J�/� � �T� �d� � �� r, r c �, � e Zd ZdZdededdfd�Zdd�Zy) �IUNIXDatagramTransportz,
Transport for UDP PacketProtocols.
r r� r0 Nc � � y)z0
Write packet to given address.
Nr+ r s r- r{ z IUNIXDatagramTransport.write� r3 r, c � � y�z)
Returns L{UNIXAddress}.
Nr+ r+ r, r- rP z IUNIXDatagramTransport.getHost� r3 r, �r0 r )r' r( r) r* r� rC r{ rP r+ r, r- r( r( � s& � �� �e� �3� �4� �
r, r( c �0 � e Zd ZdZdeddfd�Zdd�Zdd�Zy) � IUNIXDatagramConnectedTransportz5
Transport for UDP ConnectedPacketProtocols.
r r0 Nc � � y)z>
Write packet to address we are connected to.
Nr+ )r s r- r{ z%IUNIXDatagramConnectedTransport.write� r3 r, c � � yr+ r+ r+ r, r- rP z'IUNIXDatagramConnectedTransport.getHost
r3 r, c � � yr+ r+ r+ r, r- r� z'IUNIXDatagramConnectedTransport.getPeer
r3 r, r, )r' r( r) r* r� r{ rP r� r+ r, r- r. r. � s$ � �� �e� �� �
�
r, r. c � � e Zd ZdZdefd�Zdeddfd�Zdefd�Zdeddfd �Z de
fd
�Z d e
ddfd �Z ded
eddfd�Z
ded
eddfd�Zy)�IMulticastTransportz5
Additional functionality for multicast UDP.
r0 c � � y)zA
Return interface of outgoing multicast packets.
Nr+ r+ r, r- �getOutgoingInterfacez(IMulticastTransport.getOutgoingInterface
r3 r, r� Nc � � y)ze
Set interface for outgoing multicast packets.
Returns Deferred of success.
Nr+ r� s r- �setOutgoingInterfacez(IMulticastTransport.setOutgoingInterface
r3 r, c � � y)z5
Return if loopback mode is enabled.
Nr+ r+ r, r- �getLoopbackModez#IMulticastTransport.getLoopbackMode
r3 r, r� c � � y)z2
Set if loopback mode is enabled.
Nr+ )r� s r- �setLoopbackModez#IMulticastTransport.setLoopbackMode!
r3 r, c � � y)z9
Get time to live for multicast packets.
Nr+ r+ r, r- �getTTLzIMulticastTransport.getTTL&
r3 r, �ttlc � � y)z8
Set time to live on multicast packets.
Nr+ )r> s r- �setTTLzIMulticastTransport.setTTL+
r3 r, r� zDeferred[None]c � � y)z�
Join a multicast group. Returns L{Deferred} of success or failure.
If an error occurs, the returned L{Deferred} will fail with
L{error.MulticastJoinError}.
Nr+ �r� r� s r- � joinGroupz IMulticastTransport.joinGroup0
r3 r, c � � y)zG
Leave multicast group, return L{Deferred} of success.
Nr+ rB s r- �
leaveGroupz IMulticastTransport.leaveGroup8
r3 r, )r' r( r) r* rC r5 r7 r� r9 r; rD r= r@ rC rE r+ r, r- r3 r3
s� � �� �#� �
�3� �4� � �T� �
�d� �t� �
�C� �
�C� �D� �
�� �� �0@� � �� �� �1A� r, r3 c � � e Zd ZdZdeddfd�Zy)�IStreamClientEndpointz�
A stream client endpoint is a place that L{ClientFactory} can connect to.
For example, a remote TCP host/port pair would be a TCP client endpoint.
@since: 10.1
�protocolFactoryr0 zDeferred[IProtocol]c � � y)a�
Connect the C{protocolFactory} to the location specified by this
L{IStreamClientEndpoint} provider.
@param protocolFactory: A provider of L{IProtocolFactory}
@return: A L{Deferred} that results in an L{IProtocol} upon successful
connection otherwise a L{Failure} wrapping L{ConnectError} or
L{NoProtocol <twisted.internet.error.NoProtocol>}.
Nr+ �rH s r- r7 z IStreamClientEndpoint.connectF
r3 r, N)r' r( r) r* r� r7 r+ r, r- rG rG >
s � ��
�!1�
�6K�
r, rG c � � e Zd ZdZdeddfd�Zy)�IStreamServerEndpointzz
A stream server endpoint is a place that a L{Factory} can listen for
incoming connections.
@since: 10.1
rH r0 zDeferred[IListeningPort]c � � y)a,
Listen with C{protocolFactory} at the location specified by this
L{IStreamServerEndpoint} provider.
@param protocolFactory: A provider of L{IProtocolFactory}
@return: A L{Deferred} that results in an L{IListeningPort} or an
L{CannotListenError}
Nr+ rJ s r- �listenz IStreamServerEndpoint.listen[
r3 r, N)r' r( r) r* r� rN r+ r, r- rL rL S
s � �� � 0� �5O� r, rL c �8 � e Zd ZdZ ed� Zdedededefd�Z y) �!IStreamServerEndpointStringParserz�
An L{IStreamServerEndpointStringParser} is like an
L{IStreamClientEndpointStringParserWithReactor}, except for
L{IStreamServerEndpoint}s instead of clients. It integrates with
L{endpoints.serverFromString} in much the same way.
a
A C{str}, the description prefix to respond to. For example, an
L{IStreamServerEndpointStringParser} plugin which had C{"foo"} for its
C{prefix} attribute would be called for endpoint descriptions like
C{"foo:bar:baz"} or C{"foo:"}.
�reactorr� r� r0 c � � y)z�
Parse a stream server endpoint from a reactor and string-only arguments
and keyword arguments.
@see: L{IStreamClientEndpointStringParserWithReactor.parseStreamClient}
@return: a stream server endpoint
Nr+ �rQ r� r� s r- �parseStreamServerz3IStreamServerEndpointStringParser.parseStreamServerx
r3 r, N)
r' r( r) r* r �prefixr r� rL rT r+ r, r- rP rP g
s= � �� � ��F�
� �
�&,�
�8>�
� �
r, rP c �8 � e Zd ZdZ ed� Zdedededefd�Z y) �,IStreamClientEndpointStringParserWithReactora�
An L{IStreamClientEndpointStringParserWithReactor} is a parser which can
convert a set of string C{*args} and C{**kwargs} into an
L{IStreamClientEndpoint} provider.
This interface is really only useful in the context of the plugin system
for L{endpoints.clientFromString}. See the document entitled "I{The
Twisted Plugin System}" for more details on how to write a plugin.
If you place an L{IStreamClientEndpointStringParserWithReactor} plugin in
the C{twisted.plugins} package, that plugin's C{parseStreamClient} method
will be used to produce endpoints for any description string that begins
with the result of that L{IStreamClientEndpointStringParserWithReactor}'s
prefix attribute.
a!
L{bytes}, the description prefix to respond to. For example, an
L{IStreamClientEndpointStringParserWithReactor} plugin which had
C{b"foo"} for its C{prefix} attribute would be called for endpoint
descriptions like C{b"foo:bar:baz"} or C{b"foo:"}.
rQ r� r� r0 c � � y)a�
This method is invoked by L{endpoints.clientFromString}, if the type of
endpoint matches the return value from this
L{IStreamClientEndpointStringParserWithReactor}'s C{prefix} method.
@param reactor: The reactor passed to L{endpoints.clientFromString}.
@param args: The byte string arguments, minus the endpoint type, in the
endpoint description string, parsed according to the rules
described in L{endpoints.quoteStringArgument}. For example, if the
description were C{b"my-type:foo:bar:baz=qux"}, C{args} would be
C{(b'foo', b'bar')}
@param kwargs: The byte string arguments from the endpoint description
passed as keyword arguments. For example, if the description were
C{b"my-type:foo:bar:baz=qux"}, C{kwargs} would be
C{dict(baz=b'qux')}.
@return: a client endpoint
Nr+ rS s r- �parseStreamClientz>IStreamClientEndpointStringParserWithReactor.parseStreamClient�
r3 r, N)
r' r( r) r* r rU r r� rG rY r+ r, r- rW rW �
s= � �� � ��F� � � �&,� �8>� � � r, rW c � � e Zd ZdZ ed� Zy)� _ISupportsExitSignalCapturinga
An implementor of L{_ISupportsExitSignalCapturing} will capture the
value of any delivered exit signal (SIGINT, SIGTERM, SIGBREAK) for which
it has installed a handler. The caught signal number is made available in
the _exitSignal attribute.
z�
C{int} or C{None}, the integer exit signal delivered to the
application, or None if no signal was delivered.
N)r' r( r) r* r � _exitSignalr+ r, r- r[ r[ �
s � �� � ��Kr, r[ N)xr* �typingr r r r r r r r
r r r
�zope.interfacer r �twisted.python.failurer �socketr � OpenSSL.SSLr r� r r� � ImportErrorr� �twisted.internet.abstractr �twisted.internet.addressr r r �twisted.internet.deferr �twisted.internet.protocolr r r r r �twisted.internet.sslr �twisted.names.dnsr r �twisted.protocols.tlsr! �twisted.python.runtimer" �supportsThreads�twisted.python.threadpoolr# r% r/ r< rF rJ rT r] r� r� r� r� r� r� r� r� r� r� r� r� r r r r$ r* r/ r5 r� rR rV r6 r; rd rf rl rp rr r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r( r. r3 rG rL rP rW r[ r+ r, r- �<module>rm s� ��� � � � � 0� *��$�4�
� 9�N�N�/�� � :�1�:�/� �x� � �!�8��
��y� � �� �B �i� �0 �i� �( �)� �B% � � % �PO �� O �d- �)� - �`) �)� ) �X& �9� & �R) �9� ) �X �)� �6 �)� �, � � �<y �Y� y �x` �i� ` �F �9� �F7 �9� 7 �t �)� �4 � � �" �)�+<� �(A �9� A �H � � �& �I� �. � � �2< �I� < �~ �Y� �< �i� � �o� �B �o� �" �� �"�?�,<� �
�y�
� �I� �$* � � * �Z � � �" �I� �4 �I� �&+ � � + �\3 �y� 3 �l �Y� �D �� �4 �i� �$ �y� �:> �� > �B> �J� > �B �Z� �2 �i� �4 �i� �4 �)� �( �Y� �( �M� �: �M� ��-� �(R�i� R� �� �&C �
� C �L �� �.9 �I� 9 �x
�Y�
� �i� �*0 �)� 0 �f �I� �* �I� �( � � �<. �9� . �b
�I�
��eT � 4�-3�3��N�4�s �M8 �8 N�N