Ggl"u d Z ddlZddlZddlZddlZddlZddlZej d dk Zej dd dk Z ej dd dk Z
ej dd dk Z ej dd dk Z ej dd d k Z
ej dd d
k Zej d dk Zej dd d k Zej dd d k Z eed
Zd Zd Zerd Zd Zd ZefZefZ e fZ eZ e Z!n d Zd Zd Ze"fZee#fZ e ej$ fZ e%Z eZ!erd Z&nd Z&de&_ er
dMdZ'dMdZ(dNd Z)n dNd Z'dNd Z(dOd Z)d!e'_ er
d" Z*d# Z+d$ Z,d% Z-n ddl.Z.e.j/ Z*e.j0 Z+e.j1 Z,e.j2 Z-dPd'Z3d( Z4d) Z5d* Z6d+ Z7d, Z8d- Z9d. Z:d/ Z;d0 ZdQd3Z?e@fd4ZAn d5 Z> eBd6C d7eA_ e?ZDd8 ZEerd9 ZFnd: ZFd; ZGd< ZHeZIe ZJd= ZKd> ZLd? ZMd@ ZNdA ZOerddlPZP eQePdB ZRndQdCZRdD ZSdMdEZT eUj7 dF ZVdG ZWn# eX$ r dH ZVdI ZWY nw xY werdJ ZYndK ZYg dLZZdS )Ra
A selection of cross-compatible functions for Python 2 and 3.
This module exports useful functions for 2/3 compatible code:
* bind_method: binds functions to classes
* ``native_str_to_bytes`` and ``bytes_to_native_str``
* ``native_str``: always equal to the native platform string object (because
this may be shadowed by imports from future.builtins)
* lists: lrange(), lmap(), lzip(), lfilter()
* iterable method compatibility:
- iteritems, iterkeys, itervalues
- viewitems, viewkeys, viewvalues
These use the original method if available, otherwise they use items,
keys, values.
* types:
* text_type: unicode in Python 2, str in Python 3
* string_types: basestring in Python 2, str in Python 3
* binary_type: str in Python 2, bytes in Python 3
* integer_types: (int, long) in Python 2, int in Python 3
* class_types: (type, types.ClassType) in Python 2, type in Python 3
* bchr(c):
Take an integer and make a 1-character byte string
* bord(c)
Take the result of indexing on a byte string and make an integer
* tobytes(s)
Take a text string, a byte string, or a sequence of characters taken
from a byte string, and make a byte string.
* raise_from()
* raise_with_traceback()
This module also defines these decorators:
* ``python_2_unicode_compatible``
* ``with_metaclass``
* ``implements_iterator``
Some of the functions in this module come from the following sources:
* Jinja2 (BSD licensed: see
https://github.com/mitsuhiko/jinja2/blob/master/LICENSE)
* Pandas compatibility module pandas.compat
* six.py by Benjamin Peterson
* Django
N )r )r )r )r )r )r )r r )r r pypy_translation_infoc < t s| j | _ d | _ | S )u
A decorator that defines __unicode__ and __str__ methods under Python
2. Under Python 3, this decorator is a no-op.
To support Python 2 and 3 with a single code base, define a __str__
method returning unicode text and apply this decorator to the class, like
this::
>>> from future.utils import python_2_unicode_compatible
>>> @python_2_unicode_compatible
... class MyClass(object):
... def __str__(self):
... return u'Unicode string: 孔子'
>>> a = MyClass()
Then, after this import:
>>> from future.builtins import str
the following is ``True`` on both Python 3 and 2::
>>> str(a) == a.encode('utf-8').decode('utf-8')
True
and, on a Unicode-enabled terminal with the right fonts, these both print the
Chinese characters for Confucius::
>>> print(a)
>>> print(str(a))
The implementation comes from django.utils.encoding.
c P | d S Nutf-8) __unicode__encode)selfs g/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/future/utils/__init__.pyz-python_2_unicode_compatible..n s 4#3#3#5#5#<#.metaclassc \ | t | |d| S || S )N )type__new__)r name
this_basesdbasesmetas r r! z)with_metaclass..metaclass.__new__ s5 !||Cr15554eQ'' 'r N)__name__
__module__ __qualname__r __call____init__r! )r% r& s r metaclassr sA == ( ( ( ( ( ( ( (r r, temporary_classNr )r& r% r, s `` r with_metaclassr. r sT 2( ( ( ( ( ( ( (D ( ( ( 9&b 1 11r c " t | g S N)bytesss r bchrr4 s aSzzr c j t | t rt | d S t | S Nlatin-1)
isinstancestrr1 r2 s r bstrr: s/ a I&& &88Or c | S r0 r r2 s r bordr< r c t | S r0 )chrr2 s r r4 r4
1vv
r c t | S r0 )r9 r2 s r r: r: r@ r c t | S r0 )ordr2 s r r< r< r@ r c t | t r| S t | t r| d S t | S r6 )r8 r1 r9 r r2 s r tobytesrE sH a H!S!!
xx *** Qxxr c t | t r| d S d | S )Nr7 )r8 unicoder joinr2 s r rE rE s6 a ! ! 88I&& &771:: r zS
Encodes to latin-1 (where the first 256 chars are the same as
ASCII.)
r c , | | S r0 r )r3 encodings r native_str_to_bytesrM xx!!!r c , | | S r0 )decodebrL s r bytes_to_native_strrS rN r c | S r0 r trL s r text_to_native_strrW r= r c $ ddl m} || S )Nr newbytes) future.typesrZ )r3 rL rZ s r rM rM s" ))))))x{{r c t | S r0 )nativerQ s r rS rS s ayyr asciic F t | | S )z}
Use this to create a Py2 native string when "from __future__ import
unicode_literals" is in effect.
)rH r rU s r rW rW s
qzz ***r zu
On Py3, returns an encoded string.
On Py2, returns a newbytes type, ignoring the ``encoding`` argument.
c 4 t t | i | S r0 )listrangeargskwargss r lrangerf s E4*6**+++r c 4 t t | i | S r0 )ra ziprc s r lzipri C((()))r c 4 t t | i | S r0 )ra maprc s r lmaprm rj r c 4 t t | i | S r0 )ra filterrc s r lfilterrp s FD+F++,,,r Fc
|r,t d | d D S t r| S ddl}| d }t
| | S )zE
A function equivalent to the str.isidentifier method on Py3
c 3 4 K | ]}t | V d S r0 ) isidentifier).0as r z isidentifier.. s( 99q<??999999r .r Nz[a-zA-Z_][a-zA-Z0-9_]*$)allsplitr rs recompileboolmatch)r3 dottedrz _name_res r rs rs s :99AGGCLL999999
'~~ :: 899HNN1%%&&&r c F t | dd }|s| j } |di |S )z
Function for iterating over dictionary items with the same set-like
behaviour on Py2.7 as on Py3.
Passes kwargs to method. viewitemsNr getattritemsobjre funcs r r r s6 3 T * *D y 4>>&>>r c F t | dd }|s| j } |di |S )z
Function for iterating over dictionary keys with the same set-like
behaviour on Py2.7 as on Py3.
Passes kwargs to method.viewkeysNr r keysr s r r r s6 3
D ) )D x 4>>&>>r c F t | dd }|s| j } |di |S )z
Function for iterating over dictionary values with the same set-like
behaviour on Py2.7 as on Py3.
Passes kwargs to method.
viewvaluesNr r valuesr s r r r ( s6 3 d + +D z 4>>&>>r c F t | dd }|s| j } |di |S )zsUse this only if compatibility with Python versions before 2.7 is
required. Otherwise, prefer viewitems().
iteritemsNr r r s r r r 4 s6 3 T * *D y 4>>&>>r c F t | dd }|s| j } |di |S )zrUse this only if compatibility with Python versions before 2.7 is
required. Otherwise, prefer viewkeys().
iterkeysNr r r s r r r > s6 3
D ) )D x 4>>&>>r c F t | dd }|s| j } |di |S )ztUse this only if compatibility with Python versions before 2.7 is
required. Otherwise, prefer viewvalues().
itervaluesNr r r s r r r H s6 3 d + +D z 4>>&>>r c t s't | |t j |d| dS t | || dS )a/ Bind a method to class, python 2 and python 3 compatible.
Parameters
----------
cls : type
class to receive bound method
name : basestring
name of method on class instance
func : function
function to be bound as method
Returns
-------
None
N)r setattrtypes
MethodType)r r" r s r bind_methodr R sK $ !T5+D$<<=====T4 r c 4 t j d S )N )sysexc_infor r r getexceptionr j s <>>! r c p t j d } | d j }| d j }||fS )zr
Returns the globals and locals of the calling frame.
Is there an alternative to frame hacking here?
r r )inspectstack f_globalsf_locals) caller_frame myglobalsmylocalss r _get_caller_globals_and_localsr n s7 =??1%L Q)IA'H h r c t | }| d r | d r
|dd S |S )zA
Returns the string without any initial or final quotes.
'r )repr
startswithendswith)mystringrs r _repr_stripr z sF
XA||C QZZ__ 2wr c t \ }}| }| |d< ||d< d}t ||| dS )n
Equivalent to:
raise EXCEPTION from CAUSE
on Python 3. (See PEP 3134).
__python_future_raise_from_exc __python_future_raise_from_causezJraise __python_future_raise_from_exc from __python_future_raise_from_causeN)r copyexec)exccauser r execstrs r
raise_fromr sX = > > 8 NN$$ 69 238= 45^ Wi*****r c t | t r|t d | }nt | t r,t | t st d| j z t || r|}n3t |t r | | }n| | }n | | }|j |ur| | |)z
A function that matches the Python 2.x ``raise`` statement. This
allows re-raising exceptions with the cls value and traceback on
Python 2 and 3.
Nz0instance exception may not have a separate valuez,class must derive from BaseException, not %s) r8
BaseException TypeErrorr
issubclassr' tuple
__traceback__with_traceback)tpvaluetbr s r raise_r s b- ( ( RSSSCC
D
!
! *R *G*G JR[ XYY Y %$$
E5))
b%j bddbii B & &$$R(( ( r c p |t k rt j \ }}}| | r0 )Ellipsisr r r )r traceback_s r raise_with_tracebackr s2 !lnnOAq) +++r c ~ t | t r t | t r | }n| }d|_ t |t rOt |t r: | |_ t
j d |j _ d|_ n||d|_ d|_ nkt |t rG||_ t |j dt
j d d|_ nt d t
j d |_
|)r Fr TNr z/exception causes must derive from BaseExceptionr )r8 r r Exception__suppress_context__ __cause__r r r r object __setattr__r __context__)r r es r r r s c4 ZY%?%? AA A!& eT " " Oz%'C'C O %''AK(+ q(9AK %%)A " "
] AK%)A " "
}
-
- O AK q{_clnnQ>O P P P%)A " " MNN N q)
r z
def raise_(tp, value=None, tb=None):
raise tp, value, tb
def raise_with_traceback(exc, traceback=Ellipsis):
if traceback == Ellipsis:
_, _, traceback = sys.exc_info()
raise exc, None, traceback
zjRaise exception with existing traceback.
If traceback is not passed, uses sys.exc_info() to get traceback.c 4 t r| S | j | _ | `| S )a
From jinja2/_compat.py. License: BSD.
Use as a decorator like this::
@implements_iterator
class UppercasingIterator(object):
def __init__(self, iterable):
self._iter = iter(iterable)
def __iter__(self):
return self
def __next__(self):
return next(self._iter).upper()
)r __next__nextr s r implements_iteratorr s$
< L
r c | j S r0 )r xs r r r s r c | j S r0 )r r s r r r s r c l t r| S t | t r| d S | S r )r r8 rH r )filenames r encode_filenamer s8
h ( ( ,??7++ +r c d t | d o dt | v pt | d S )a
Python 2.7 has both new-style and old-style classes. Old-style classes can
be pesky in some circumstances, such as when using inheritance. Use this
function to test for whether a class is new-style. (Python 3 only has
new-style classes.)
__class____dict__ __slots__)hasattrdirr s r is_new_styler # s= 3 $ $ H*C*@ +G-4S+-F-FHr c < t | t d S )z
Deprecated. Use::
>>> isinstance(obj, str)
after this import:
>>> from future.builtins import str
rG r8 r r s r istextr 3 c499 % %%r c < t | t d S )z
Deprecated. Use::
>>> isinstance(obj, bytes)
after this import:
>>> from future.builtins import bytes
r r r s r isbytesr = r r c 2 t | j dk S )a
Equivalent to the result of ``type(obj) == type(newbytes)``
in other words, it is REALLY a newbytes instance, not a Py2 native str
object?
Note that this does not cover subclasses of newbytes, and it is not
equivalent to ininstance(obj, newbytes)
rZ )r r' r s r
isnewbytesr G s 99 ++r c 6 t | t j S )a_
Deprecated. Tests whether an object is a Py3 ``int`` or either a Py2 ``int`` or
``long``.
Instead of using this function, you can use:
>>> from future.builtins import int
>>> isinstance(obj, int)
The following idiom is equivalent:
>>> from numbers import Integral
>>> isinstance(obj, Integral)
r8 numbersIntegralr s r isintr S s c7+ , ,,r c N t | d r| S | S )aO
On Py3, this is a no-op: native(obj) -> obj
On Py2, returns the corresponding native Py2 types that are
superclasses for backported objects from Py3:
>>> from builtins import str, bytes, int
>>> native(str(u'ABC'))
u'ABC'
>>> type(native(str(u'ABC')))
unicode
>>> native(bytes(b'ABC'))
b'ABC'
>>> type(native(bytes(b'ABC')))
bytes
>>> native(int(10**20))
100000000000000000000L
>>> type(native(int(10**20)))
long
Existing native types on Py2 will be returned unchanged:
>>> type(native(u'ABC'))
unicode
__native__)r r r s r r] r] f s+ : sL!! ~~
r r c | |&t j d }|j }||j }~n||}t d dS )z Execute code in a namespace.Nr zexec code in globs, locs)r _getframer r r )codeglobslocsframes r exec_r sM =M!$$EOE| ~
\D
+,,,,,r c ~ t | t j r t |t j r| |z S | |z S )z
DEPRECATED: import ``old_div`` from ``past.utils`` instead.
Equivalent to ``a / b`` on Python 2 without ``from __future__ import
division``.
TODO: generalize this to other objects (like arrays etc.)
r )ru rR s r old_divr s? !W%&& :a9I+J+J Av
1u r c & t rd S fd}|S )a~
A decorator to turn a function or method call that returns text, i.e.
unicode, into one that returns a native platform str.
Use it as a decorator like this::
from __future__ import unicode_literals
class MyClass(object):
@as_native_str(encoding='ascii')
def __repr__(self):
return next(self._iter).upper()
c | S r0 r )fs r r z as_native_str.. s r c J t j fd }|S )Nc < | i | S )N)rL rK )rd re rL r s r wrapperz/as_native_str..encoder..wrapper s) q$)&))00(0CCCr ) functoolswraps)r r rL s ` r encoderz as_native_str..encoder sB
_Q
D
D
D
D
D
DNr )r )rL r s ` r
as_native_strr s5 {
r c * | S r0 )r r$ s r
listvaluesr s xxzzr c * | S r0 )r r
s r listitemsr
s wwyyr c D t | S r0 )ra r r
s r r r s AHHJJ r c D t | S r0 )ra r r
s r r
r
s AGGII r c | S r0 r r s r ensure_new_typer s
r c ddl m} ddlm} ddlm} ddlm} t t | }t |t | rp|t k r || S |t k r || S |t k r || S |t k r || S |t k r || S | S t | ||fv sJ | S )Nr rY )newstr)newint)newdict)future.types.newbytesrZ future.types.newstrr future.types.newintr future.types.newdictr r r] r r9 rH intlongdict)r rZ r r r native_types r r r s 222222............0000006#;;'' k499 - - c!! x}}$ '' vc{{" ## vc{{" $$ vc{{" $$ ws||#
996 22222Jr )2PY2PY26r PYPYr binary_typer r< r: rS class_typesr r r get_nextr r
integer_typesr r rs r r r r r r rp r
r rm rf ri r] native_bytes
native_strrM r r r r reraise string_typesrW text_typerE r r r r. )r r0 )r^ )F)NN)[__doc__r r r r r r version_infor PY34_PLUS PY35_PLUS PY36_PLUS PY37_PLUS PY38_PLUS PY39_PLUSr r PY27r r r r. r4 r: r< r9 r( r r$ r r" r) r1 r!
basestringr ClassTyperH rE rM rS rW rf ri rm rp __builtin__rb rh rl ro rs r r r r r r r r r r r r r r r stripr' r r# r r r& r% r r r r r] builtinsr r r r r r r
AttributeErrorr __all__r r r r: s: 1 1f
qQ QqS !V + QqS !V + QqS !V + QqS !V + QqS !V + QqS !V + qQ
! &
! &ws+,,& & &R 2 2 2H
4LDM%KIKK ;L$KM )KIK
+" " " "" " " " + + + +
!, , ,* * ** * *- - - -
F ?D ?D G ' ' ' ' ! ! !0 k
+ + +$$ $ $ $L -5 , , , , , " " "H D
EGG
E . ##HH H H H H
& & && & & , , ,- - -& H -OOO GHf % %EE
-
-
-
- 4
NN :
s H* * H87H8