9iUSrSSKrSSKrSSKrSSKrSSKrSSKr\RSS:r\RSSS:r \RSSS:r \RSSS:r \RSSS:r \RSSS :r \RSSS :r\RSS:Hr\RSSS :Hr\RSSS :Hr\"\S 5rSrSr\(aSrSrSr\4r\4r\4r\r\ r!O"SrSrSr\"4r\\#4r\\RH4r\%r\r!\(aSr&OSr&S\&l\(aSJSjr'SJSjr(SKSjr)OSKSjr'SKSjr(SLSjr)S\'l\(a S r*S!r+S"r,S#r-O4SSK.r.\.R^r*\.R`r+\.Rbr,\.Rdr-SMS$jr3S%r4S&r5S'r6S(r7S)r8S*r9S+r:S,r;S-rSNS0jr?\@4S1jrAOS2r>\B"S3R55 S4\Al\?rDS5rE\(aS6rFOS7rFS8rGS9rH\rI\ rJS:rKS;rLS<rMS=rNS>rO\(aSSKPrP\Q"\PS?5rROSNS@jrRSArSSJSBjrT\URn SCrVSDrW\(aSGrYOSHrY/SIQrZg!\Xa SErVSFrWN!f=f)Oa 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 )rr)rrpypy_translation_infocN[(dURUlSUlU$)uN 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@UR5RS5$Nutf-8) __unicode__encode)selfs U/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/future/utils/__init__.py-python_2_unicode_compatible..ns4#3#3#5#<#\rSrSr\R r\R rUU4SjrSrg)z!with_metaclass..metaclasscL>Uc[RXSU5$T"UTU5$)N)type__new__)rname this_basesdbasesmetas rr")with_metaclass..metaclass.__new__s+!||Cr155eQ' 'rr N) __name__ __module__ __qualname____firstlineno__r!__call____init__r"__static_attributes__)r&r'sr metaclass!with_metaclass..metaclasss==== ( (rr0temporary_classNr )r'r&r0s`` rwith_metaclassr3rs&2((D( &b 11rc[U/5$N)bytesss rbchrr9saSzrcZ[U[5(a [US5$[U5$Nlatin-1) isinstancestrr6r7s rbstrr?s% a  I& &8OrcU$r5r r7s rbordrArc[U5$r5)chrr7s rr9r9 1v rc[U5$r5)r>r7s rr?r?rErc[U5$r5)ordr7s rrArArErc[U[5(aU$[U[5(aURS5$[U5$r;)r=r6r>rr7s rtobytesrJs9 a  H!S!!xx **Qxrcp[U[5(aURS5$SRU5$)Nr<)r=unicoderjoinr7s rrJrJs, a ! !88I& &771: rzS Encodes to latin-1 (where the first 256 chars are the same as ASCII.) c$URU5$r5r)r8encodings rnative_str_to_bytesrRxx!!rc$URU5$r5)decodebrQs rbytes_to_native_strrXrSrcU$r5r trQs rtext_to_native_strr\rBrcSSKJn U"U5$)Nrnewbytes) future.typesr_)r8rQr_s rrRrRs){rc[U5$r5)nativerVs rrXrXs ayrc6[U5RU5$)ze Use this to create a Py2 native string when "from __future__ import unicode_literals" is in effect. )rMrrZs rr\r\s qz  **rzu On Py3, returns an encoded string. On Py2, returns a newbytes type, ignoring the ``encoding`` argument. c*[[U0UD65$r5)listrangeargskwargss rlrangerjsE4*6*++rc*[[U0UD65$r5)reziprgs rlziprmC(())rc*[[U0UD65$r5)remaprgs rlmaprqrnrc*[[U0UD65$r5)refilterrgs rlfilterrtsFD+F+,,rcU(a![SURS555$[(aUR5$SSKnUR S5n[ URU55$)z= A function equivalent to the str.isidentifier method on Py3 c38# UHn[U5v M g7fr5) isidentifier).0as r isidentifier..s9Lq<??Ls.rNz[a-zA-Z_][a-zA-Z0-9_]*$)allsplitrrwrecompileboolmatch)r8dottedr_name_res rrwrwsX9AGGCL999 s~~::89HNN1%&&rc R[USS5nU(d URnU"S0UD6$)z| Function for iterating over dictionary items with the same set-like behaviour on Py2.7 as on Py3. Passes kwargs to method. viewitemsNr getattritemsobjrifuncs rrrs* 3 T *D yy >&>rc R[USS5nU(d URnU"S0UD6$)z{ Function for iterating over dictionary keys with the same set-like behaviour on Py2.7 as on Py3. Passes kwargs to method.viewkeysNr rkeysrs rrrs* 3 D )D xx >&>rc R[USS5nU(d URnU"S0UD6$)z} Function for iterating over dictionary values with the same set-like behaviour on Py2.7 as on Py3. Passes kwargs to method. viewvaluesNr rvaluesrs rrr(s* 3 d +D zz >&>rc R[USS5nU(d URnU"S0UD6$)zkUse this only if compatibility with Python versions before 2.7 is required. Otherwise, prefer viewitems(). iteritemsNr rrs rrr4s* 3 T *D yy >&>rc R[USS5nU(d URnU"S0UD6$)zjUse this only if compatibility with Python versions before 2.7 is required. Otherwise, prefer viewkeys(). iterkeysNr rrs rrr>s* 3 D )D xx >&>rc R[USS5nU(d URnU"S0UD6$)zlUse this only if compatibility with Python versions before 2.7 is required. Otherwise, prefer viewvalues(). itervaluesNr rrs rrrHs* 3 d +D zz >&>rc x[(d#[X[R"USU55 g[XU5 g)zBind 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)rsetattrtypes MethodType)rr#rs r bind_methodrRs,$ 35++D$<=4 rc2[R"5S$)N)sysexc_infor rr getexceptionrjs <<>! rct[R"5SnUSRnUSRnX4$)zf Returns the globals and locals of the calling frame. Is there an alternative to frame hacking here? rr)inspectstack f_globalsf_locals) caller_frame myglobalsmylocalss r_get_caller_globals_and_localsrns; ==?1%LQ))IA''H  rc~[U5nURS5(aURS5(aUSS$U$)z9 Returns the string without any initial or final quotes. 'r)repr startswithendswith)mystringrs r _repr_striprzs8 XA||CQZZ__2wrch[5up#UR5nXS'XS'Sn[XBU5 g)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)rcopyexec)exccauserrexecstrs r raise_fromrs>=> NN$ 69238=45^ W*rc[U[5(aUb [S5eUnO[U[5(a-[ U[5(d[SUR -5e[X5(aUnO.[U[ 5(aU"U6nOUcU"5nOU"U5nURULaURU5eUe)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. z0instance exception may not have a separate valuez,class must derive from BaseException, not %s) r= BaseException TypeErrorr! issubclassr)tuple __traceback__with_traceback)tpvaluetbrs rraise_rs b- ( (  RSSC D ! !*R*G*GJR[[XY Y%$$E5))%jdi   B &$$R( ( rchU[:Xa[R"5u p!URU5er5)Ellipsisrrr)r traceback_s rraise_with_tracebackrs*  !llnOAq  ++rcn[U[5(a[U[5(aU"5nOUnSUl[U[5(aP[U[5(a;U"5Ul[ R"5SUR lSUlOwUcSUlSUlOe[U[5(aEXl[RUR S[ R"5S5 SUlO [S5e[ R"5SUl Ue)rFrTNrz/exception causes must derive from BaseExceptionr)r=r!r Exception__suppress_context__ __cause__rrrrobject __setattr__r __context__)rres rrrs c4 ZY%?%?A A!& eT " "z%'C'C'AK(+ q(9AKK %%)A " ]AK%)A " } - -K   q{{_cllnQ>O P%)A "MN N q) rz 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.cF[(aU$URUlU?U$)aS 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__nextrs rimplements_iteratorrs#  s << L rcUR$r5)rxs rrrsrcUR$r5)rrs rrrsrcl[(aU$[U[5(aURS5$U$r)rr=rMr)filenames rencode_filenamers- s h ( (??7+ +rcj[US5=(a! S[U5;=(d [US5$)z 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__)hasattrdirrs r is_new_styler#s5 3 $ H*C*@+G-4S+-FHrc,[U[S55$)zk Deprecated. Use:: >>> isinstance(obj, str) after this import: >>> from future.builtins import str rLr=r!rs ristextr3 c49 %%rc,[U[S55$)zo Deprecated. Use:: >>> isinstance(obj, bytes) after this import: >>> from future.builtins import bytes rrrs risbytesr=rrc2[U5RS:H$)z 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) r_)r!r)rs r isnewbytesrGs 9   ++rc6[U[R5$)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) r=numbersIntegralrs risintrSs c7++ ,,rcH[US5(aUR5$U$)a 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__)rrrs rrbrbfs#:sL!!~~ rrcUc3[R"S5nURnUc URnAOUcUn[ S5 g)zExecute code in a namespace.Nrzexec code in globs, locs)r _getframerrr)codeglobslocsframes rexec_rsB =MM!$EOOE|~~ \D +,rc[U[R5(a#[U[R5(aX-$X- $)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)ryrWs rold_divrs7!W%%&&:a9I9I+J+Jv u rc0^[(aS$U4SjnU$)aZ 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() cU$r5r )fs rras_native_str..srcJ>^[R"T5UU4Sj5nU$)Nc.>T"U0UD6RTS9$)N)rQrP)rhrirQrs rwrapper/as_native_str..encoder..wrappers!$)&)00(0CCr) functoolswraps)rr rQs` rencoderas_native_str..encoders% __Q  D  DNr)r)rQrs` r as_native_strrs s  rc"UR5$r5)rr%s r listvaluesrsxxzrc"UR5$r5)rrs r listitemsrswwyrc4[UR55$r5)rerrs rrrsAHHJrc4[UR55$r5)rerrs rrrsAGGIrcU$r5r rs rensure_new_typers rcnSSKJn SSKJn SSKJn SSKJn [[U55n[U[U55(a\U[:XaU"U5$U[:XaU"U5$U[:XaU"U5$U[:XaU"U5$U[:XaU"U5$U$[U5X4;deU$)Nrr^)newstr)newint)newdict)future.types.newbytesr_future.types.newstrrfuture.types.newintrfuture.types.newdictrr!rbrr>rMintlongdict)rr_rrr native_types rrrs2..06#;'  k49 - -c!}$'c{"#c{"$c{"$s|# 9 22 22Jr)2PY2PY26rPYPYr binary_typerrAr?rX class_typesrrrget_nextrr integer_typesrrrwrrrrrrrtrrrqrjrmrb native_bytes native_strrRrrrrreraise string_typesr\ text_typerJrrrr3)rr5)ascii)F)NN)[__doc__rrrr rr version_infor PY34_PLUS PY35_PLUS PY36_PLUS PY37_PLUS PY38_PLUS PY39_PLUSr&r'PY27rr(rr3r9r?rAr>r0r"r,r!r*r1r6r) basestringr# ClassTyperMrJrRrXr\rjrmrqrt __builtin__rfrlrprsrwrrrrrrrrrrrrrrrstripr/rr+rrr.r-rrrrrbbuiltinsrrrrr$rrAttributeErrorr__all__r rrrCsJ1f   qQ   Qq !V +   Qq !V +   Qq !V +   Qq !V +   Qq !V +   Qq !V +  qQ !& !&s+,&R 2H 4LDM%KIK;L$KM)KIK   ""+ ,**-   F ??D ??D  G '   !0 +$$L-5, "H   EG E .#HHH  && ,-& H Hf %E - 4 NN: ]  s I55 JJ