/usr/lib/python3/dist-packages/twisted/python/__pycache__
Edit: /usr/lib/python3/dist-packages/twisted/python/__pycache__/compat.cpython-310.pyc (15398B)
o
b#B @ s d Z ddlZddlZddlZddlZddlZddlmZ ddl Z ddl
m Z ddl m
Z
ddlmZ ddlmZ ddlmZmZmZ ddlmZ dd lmZmZ dd
l m Z m Z m Z dd lm!Z"m#Z$ dd l%m&Z& dd
l'm(Z(m)Z) ej*dkrxdZ+ndZ+e, dkrdZ-ndZ-eZ.e)e&ddddde/d e0Z0e)e&ddddde/d e1Z2e)e&ddddde/d e3Z4e)e&ddddde/d e5Z6e)e&ddddd e/d e7Z7e)e&ddddd e/d e8Z9e)e&ddddd!e/d" e:Z:e)e&ddddd#e/d$ e;Z
e)e&ddddd'e/d( e;Z?e)e&ddddd%e/d) e7Z@e)e&ddddd e/d* e(e&ddddd+d,d-d. ZAe(e&ddddd/d,d0d1 ZBe(e&ddddd2d,d3d4 ZCdqd5e5d6efd7d8ZDdrd9d:ZEd;e1dZFd?d@ ZGe;fdAdBZHdCe d6e;fdDdEZIdFdG ZJe(e&dddddHd,dIdJ ZKdKdL ZLe(e&dddddMd,dNe5d6eMfdOdPZNdsdQdRZOdCe;d6eMfdSdTZPe(e&dddddUd,dVdW ZQdXdY ZRdrdZd[ZSd\d] ZTeT e)e&ddddd^e/d_ e)e&ddddd`e/da e)e&dddddbe/dc e)e&dddddde/de e)e&dddddfe/dg e)e&dddddhe/di e)e&dddddje/dk e)e&dddddle/dm e)e&dddddne/do g dpZUdS )ta)
Compatibility module to provide backwards compatibility for useful Python
features.
This is mainly for use of internal Twisted code. We encourage you to use
the latest version of Python directly from your code, if possible.
@var unicode: The type of Unicode strings, C{unicode} on Python 2 and C{str}
on Python 3.
@var NativeStringIO: An in-memory file-like object that operates on the native
string type (bytes in Python 2, unicode in Python 3).
@var urllib_parse: a URL-parsing module (urlparse on Python 2, urllib.parse on
Python 3)
N)Sequence)reduce)escape) cookiejar)IOBaseStringIO
TextIOBase)intern) FrameType
MethodType)AnyAnyStrcast)quoteunquote)Version)
deprecateddeprecatedModuleAttribute) r TFPyPyTwisted z Obsolete alias for io.IOBaseFileTypez)Obsolete alias for frozenset builtin type frozensetz)Old-style classes don't exist in Python 3 InstanceTypez Obsolete alias for zip() builtinizipz#Obsolete alias for int builtin typelongz"Obsolete alias for range() builtinrangez"Obsolete alias for input() builtin raw_inputz#Obsolete alias for set builtin typesetz#Obsolete alias for str builtin type
StringTypez Obsolete alias for chr() builtinunichrunicodexrangez d.items()) replacementc C | S )z]
Return an iterable of the items of C{d}.
@type d: L{dict}
@rtype: iterable
)itemsd r+ 7/usr/lib/python3/dist-packages/twisted/python/compat.py iteritems r- z
d.values()c C r' )z^
Return an iterable of the values of C{d}.
@type d: L{dict}
@rtype: iterable
)valuesr) r+ r+ r,
itervalues r. r0 zlist(d.items())c C s t | S )zW
Return a list of the items of C{d}.
@type d: L{dict}
@rtype: L{list}
)listr( r) r+ r+ r, r( s r( nreturnc C s< t }t| d D ] }|dusJ |j}q
|dus J |S )a`
In Python 3, L{inspect.currentframe} does not take a stack-level argument.
Restore that functionality from Python 2 so we don't have to re-implement
the C{f_back}-walking loop in places where it's called.
@param n: The number of stack levels above the caller to walk.
@return: a frame, n levels up the stack from the caller.
N)inspect currentframer f_back)r2 fxr+ r+ r, r6 s
r6 c C sZ |du r|}t | d }| }W d n1 sw Y t|| d}t||| dS )az
Execute a Python script in the given namespaces.
Similar to the execfile builtin, but a namespace is mandatory, partly
because that's a sensible thing to require, and because otherwise we'd
have to do some frame hacking.
This is a compatibility implementation for Python 3 porting, to avoid the
use of the deprecated builtin C{execfile} function.
Nrbexec)openreadcompiler; )filenameglobalslocalsfinsourcecoder+ r+ r, execfile s
rE abc C s | |k rdS | |kr dS dS )z
Compare two objects.
Returns a negative number if C{a < b}, zero if they are equal, and a
positive number if C{a > b}.
r r4 r+ )rF rG r+ r+ r, cmp s
rI c C s dt dtdtfdd}dt dtdtfdd}dt dtdtfdd }dt dtdtfd
d }dt dtdtfd d
}dt dtdtfdd}|| _|| _|| _|| _|| _|| _| S )z
Class decorator that ensures support for the special C{__cmp__} method.
C{__eq__}, C{__lt__}, etc. methods are added to the class, relying on
C{__cmp__} to implement their comparisons.
selfotherr3 c S s$ t t| |}|tu r|S |dkS Nr r bool__cmp__NotImplementedrJ rK cr+ r+ r, __eq__ zcomparable..__eq__c S s$ t t| |}|tu r|S |dkS rL rM rQ r+ r+ r, __ne__ rT zcomparable..__ne__c S s$ t t| |}|tu r|S |dk S rL rM rQ r+ r+ r, __lt__ rT zcomparable..__lt__c S s$ t t| |}|tu r|S |dkS rL rM rQ r+ r+ r, __le__
rT zcomparable..__le__c S s$ t t| |}|tu r|S |dkS rL rM rQ r+ r+ r, __gt__ rT zcomparable..__gt__c S s$ t t| |}|tu r|S |dkS rL rM rQ r+ r+ r, __ge__ rT zcomparable..__ge__) r objectrN rV rX rW rY rS rU )klassrS rU rV rW rX rY r+ r+ r,
comparable s r\ c C sR t | trtS t | trtS t| dd}ddl}t | |j|jfr'|r%tS tS |S )a
Determine the type which will be returned from the given file object's
read() and accepted by its write() method as an argument.
In other words, determine whether the given file is 'opened in text mode'.
@param fileIshObject: Any object, but ideally one which resembles a file.
@type fileIshObject: L{object}
@param default: A default value to return when the type of C{fileIshObject}
cannot be determined.
@type default: L{type}
@return: There are 3 possible return values:
1. L{str}, if the file is unambiguously opened in text mode.
2. L{bytes}, if the file is unambiguously opened in binary mode.
3. The C{default} parameter, if the given type is not understood.
@rtype: L{type}
encodingNr )
isinstancer strr bytesgetattrcodecs StreamReader StreamWriter)
fileIshObjectdefaultr] rb r+ r+ r, ioType% s
rg sc C s< t | ttfs
td| t | tr| dS | d | S )z
Convert C{bytes} or C{str} to C{str} type, using ASCII encoding if
conversion is necessary.
@raise UnicodeError: The input string is not ASCII encodable/decodable.
@raise TypeError: The input is neither C{bytes} nor C{str}.
z%r is neither bytes nor strascii)r^ r` r_ TypeErrordecodeencoderh r+ r+ r, nativeStringP s
rn c C s8 t | tr | d}n| d}t| t|kr| S |S )a
Some functions, such as C{os.path.join}, operate on string arguments which
may be bytes or text, and wish to return a value of the same type. In
those cases you may wish to have a string constant (in the case of
C{os.path.join}, that constant would be C{os.path.sep}) involved in the
parsing or processing, that must be of a matching type in order to use
string operations on it. L{_matchingString} will take a constant string
(either L{bytes} or L{str}) and convert it to the same type as the
input string. C{constantString} should contain only characters from ASCII;
to ensure this, it will be encoded or decoded regardless.
@param constantString: A string literal used in processing.
@type constantString: L{str} or L{bytes}
@param inputString: A byte string or text string provided by the user.
@type inputString: L{str} or L{bytes}
@return: C{constantString} converted into the same type as C{inputString}
@rtype: the type of C{inputString}
ri )r^ r` rk rl type)constantString inputString otherTyper+ r+ r, _matchingStringb s
rs z)raise exception.with_traceback(traceback)c C s
| |)a"
Re-raise an exception, with an optional traceback.
Re-raised exceptions will be mutated, with their C{__traceback__} attribute
being set.
@param exception: The exception instance.
@param traceback: The traceback to use, or L{None} indicating a new
traceback.
)with_traceback) exception tracebackr+ r+ r, reraise s
rw c c s* t t| D ] }| ||d V qdS )a5
Return an iterable wrapper for a C{bytes} object that provides the behavior
of iterating over C{bytes} on Python 2.
In particular, the results of iteration are the individual bytes (rather
than integers as on Python 3).
@param originalBytes: A C{bytes} object that will be wrapped.
r4 N)r len)
originalBytesir+ r+ r, iterbytes s
r{ zb'%d'rz c C s
d| f S )z
Convert the given integer into C{bytes}, as ASCII-encoded Arab numeral.
@param i: The C{int} to convert to C{bytes}.
@rtype: C{bytes}
s %dr+ )rz r+ r+ r,
intToBytes s
r| c C s, t | }|du r||d S |||| S )aq
Return a copy of the given bytes-like object.
If an offset is given, the copy starts at that offset. If a size is
given, the copy will only be of that length.
@param object: C{bytes} to be copied.
@param offset: C{int}, starting index of copy.
@param size: Optional, if an C{int} is given limit the length of copy
to this size.
N)
memoryview)rZ offsetsizeviewr+ r+ r,
lazyByteSlice s r c C s t | ts td| dS )a
Convert a string to L{bytes} using ASCII encoding.
This is useful for sending text-like bytes that are constructed using
string interpolation. For example::
networkString("Hello %d" % (n,))
@param s: A string to convert to bytes.
@type s: L{str}
@raise UnicodeError: The input string is not ASCII encodable.
@raise TypeError: The input is not L{str}.
@rtype: L{bytes}
z!Can only convert strings to bytesri )r^ r_ rj rl rm r+ r+ r,
networkString s
r z os.environbc s* t jj t jj fddt j D S )z
Return a L{dict} of L{os.environ} where all text-strings are encoded into
L{bytes}.
This function is POSIX only; environment variables are always text strings
on Windows.
c s i | ] \}} ||qS r+ r+ ).0r9 y encodekey encodevaluer+ r,
s z bytesEnviron..)osenvironr r r( r+ r+ r r, bytesEnviron s r c C s | j | }t||S )aN
Construct a bound method.
@param cls: The class that the method should be bound to.
@type cls: L{type}
@param name: The name of the method.
@type name: native L{str}
@param self: The object that the method is bound to.
@type self: any object
@return: a bound method
@rtype: L{_MethodType}
)__dict__ _MethodType)clsnamerJ funcr+ r+ r, _constructMethod s
r c K sB d|v r t jdtdd | du rd|v r|d} |r tt| S )a
Provide a backwards-compatible way to get async param value that does not
cause a syntax error under Python 3.7.
@param isAsync: isAsync param value (should default to None)
@type isAsync: L{bool}
@param kwargs: keyword arguments of the caller (only async is allowed)
@type kwargs: L{dict}
@raise TypeError: Both isAsync and async specified.
@return: Final isAsync param value
@rtype: L{bool}
asyncz:'async' keyword argument is deprecated, please use isAsyncr )
stacklevelN)warningswarnDeprecationWarningpoprj rN )isAsynckwargsr+ r+ r, _get_async_param s
r c sj z ddl m mm W n
ty Y dS w tsdS d fdd } tjj| jkr0dS | t_dS )z
Work around U{https://foss.heptapod.net/pypy/pypy/-/issues/3051}
by replacing C{socket.fromfd} with a more conservative version.
r )F_GETFLF_SETFLfcntlNc
sJ |g|d u }| }z| ||g|R W | | S | | w Nr+ )fdfamilyro proto passprotoflagsr r r
realFromFDr+ r, fromFDWithoutModifyingFlags# s
z7_pypy3BlockingHack..fromFDWithoutModifyingFlagsr )r r r ImportError_PYPYsocketfromfd__name__)r r+ r r, _pypy3BlockingHack s
r z Use functools.reduce() directlyr zUse io.StringIO directlyNativeStringIOz Import urllib.parse directly urllib_parsezUse html.escape directlyr z!Use urllib.parse.quote() directlyurlquotez#Use urllib.parse.unquote() directly
urlunquotezUse http.cookiejar directly cookielibzUse sys.intern() directlyr z%Use collections.abc.Sequence directlyr )!rw rE r r r! rI r\ rn r r r$ r{ r| r r" r r r( r- r0 r r% r r r r r r r r# r r r )r r )r N)V__doc__r5 r platformr sys urllib.parseparser r collections.abcr functoolsr htmlr httpr r ior r r r r typesr
r r typingr r
r r r r r incrementalr twisted.python.deprecater r version_info _PY37PLUSpython_implementationr r r r rZ r zipr intr r inputr r! r_ r" chrr# r$ r% r- r0 r( r6 rE rI r\ rg rn rs rw r{ r` r| r r r r r r __all__r+ r+ r+ r, sv
5+