From 4a1f8eafeed8b8c1860304fbc480d30f52e4a292 Mon Sep 17 00:00:00 2001 From: KhiemNCode05 <119762023+K-coder05@users.noreply.github.com> Date: Fri, 27 Sep 2024 05:54:29 +0000 Subject: [PATCH 1/2] django tutorial for khiem --- trydjango/pages/views.py | 6 ++++++ trydjango/products/models.py | 9 +++++++++ trydjango/trydjango/urls.py | 24 ++++++++++++++++++++++++ 3 files changed, 39 insertions(+) create mode 100644 trydjango/pages/views.py create mode 100644 trydjango/products/models.py create mode 100644 trydjango/trydjango/urls.py diff --git a/trydjango/pages/views.py b/trydjango/pages/views.py new file mode 100644 index 0000000000..1192236b60 --- /dev/null +++ b/trydjango/pages/views.py @@ -0,0 +1,6 @@ +from django.http import HttpResponse +from django.shortcuts import render + +# Create your views here. +def home_view(*args, **kwargs): + return HttpResponse("
HPr3`ef%2t}?8|!tb-77%l2j(-8=cMVq36Y|&7A9+yaDwT5Y(yP z$4gkq!IwHqjXvRT(4AhRs3-97d!nJGqqDEqie!=GU}2FJcWkA&pLgB6LoY~2)Yoa! z7qT@DbDR1q20o)@XdB?Pg6^3?5oz!WJrhUfVqk*dK=9i&a_)rrze3+behgs7+bup+4qNh-;4`;Y|l(B z;GnQy+$$aspBC3g#aKpheRMJ!$d(I(b^okA4757;XB0zxq~j)%=P;0Rz@OT$eJSvI zP2pYc;rV~Z#YU^g?62O&HeC`R2cq$tHB*rdCKf~kOcE;%kdhMo8mv&&ERCzgo=BaT zfbwQyAvnV$jk%sg_$@SY5-a_YlQqS7wtgE+X`5$-Wo{Z(zQjjgeX7KV%#VOWGtzf- z4-GOu_K>N0eIVo(5msyWXpFxRD~+l;T7ql*EB0O1KW(zO*sZ7!ILwu^Khb*r6l|m! zfGEt?&JwN>2Wh}r+FNB&+=H9_oNZNv^*03^Y$ c;!2g6Ip z{+dK4RlrGn`~NF&ZeFmb)}ML_Q>z*^Z&5?+k;+3MeNK~$+2ZMW{Q$#b(wsNdAJM}k zCY+%aD!=3RYja7(kK9(8?CP*+5>O$`s(Z~=Qq7{SI#pH_`L(2c?Osa`D7J#DXto+w zx?aPiN0O!VfDo!9j3V5qXKB@fHhH~BDvM?uy#;O0%d_V?z Pz(ma?&0i! zf~Bh;>tccPQgi4Bf{Gdr(Q{Nwb03=HrffTBU%mLo>w5I;g;!pAb2>Px4tDjcsJYbR zdofhC41v^nG>PR$6w&4Ym@&0_2M_!hSBgGs^tI#kFg@TytVh@ =2Xr z{Ca 45E6b8~d9`mUug6A?&0pL_H((!0<^ihWP zH5ntjcl R*ZkNo?5{X?=~W57Ch`L#>M&==(=p6ViI|I4vA=>@)k%*o&5>JezWB zN*cjaTu?k^jt1HOe k4bAx?)5a$CPGTR7gLp1pYf{2LduWm=Hs(C7a` zP`|_sDM4L6PB|H2pt_9ew7)G~?Qe3B9mnD803{VmH2 f6*m*9yES8h4WcDng$6gqi|1AD~GVkLWO`pNygvxkrgBdI62iD;4|e z2CtOt3R=2K_M-jY2G@VTF-yi{<3IH~jdG^l8C)DeZ_Kxht~IER{Vk$so$lj*8%tTK z)P4W@`r5UdTKc4noq1H#*i7c|4;7TUTq=kiCx2pl0+|{{e?^<1l^Iu5+nAAxe8&}B z5fu_ADFs>8Phe5VV$4QCn)HXh;!jX5Mk;OMe~833wt5CHQLV*Nnrvn)mTZB}Oy>(@ zi_Lb*6(#w{g0$?qC{s!0y8ldXryCemX-6o FwNq&Ttv5^6 z@U&v7nNSxnscx%lk-C(mZB l#;DZ#r@l_KQ|tsgQLt@;$CdZiE0*O<$p g`k0&S~rX*xjqF^Gc H^&qz$p_5+G>#m8sn7UUO|#K+&_PRWnYFH0>d%1lXJ$xy@sGzCojiqJ35 zFUl@1NK8&G)_2KD%uCOANzKjIFDa@_0rT{8GL!TRDoZl*^NjT@^ouh~Qgwl C_euxn!YsQg3Mz*$yz&p2i;n zNB*TA;k18%!!Gdbwqv;Q%k%4d-}m`Be%Ed{3>foQzmq4HVf<2yhXZ298<^rL7-A5V z84DC5WDqknDWc{L3N2D6HgUe9&?dEs;kmbvYj|kgOsR}MQZ87Ld(N#1(OaZU9n9KE zSRQ9w1*S7)cf$ck@%CVfOE3fxQ}M18FCtcEF07TQeLJ%k&dSohlhqdWm5q$0y)-Xf zn0q&nwKRCRv|!aBwJVp8Nj+EpH*NrJiM}<#Z+%zDTKkuu4Gg1K hDDl^Ur zE{n3tV!7c1e9URegyh#<4KkrpE0J?fV{(`kvpB;Q&o~uDrdo`}jI&bWlGB8J#w@`X zpgP(tFEFT{@``T2bkE^@Y~T^_c6a*&e_vH?u(ri2c&|CyY7Xv@@3q4wxs3C)=qezt zPW3*bD!BVF0%`@{Q;|p8s!Fm )Um>e>xiX`q88} z9-dF5;P`Dnba(v -zitcrqLX>t?jOKT)J>we$z3 Xt 0-I|wK0k9$aZPV)4<5{uw`Z9 z1sIrcnpWZ@pLO &>S-+tzc|+ z(lO-1I&iI NriZN*VY-?kH+^>Gy%Itt)-a1$a8$S(<{j vG`MXyoK|X1JJO5%l6n scz~%L}8D4eXuW{Vr+eQ7sX)?rrK=O7+ literal 0 HcmV?d00001 diff --git a/trydjango/lib/python3.8/site-packages/django/__pycache__/shortcuts.cpython-38.pyc b/trydjango/lib/python3.8/site-packages/django/__pycache__/shortcuts.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfdc744a78bb59360ac3a0eae7e347cdfb007cfa GIT binary patch literal 4840 zcmd^D-EJGl72aQRwfeRErvyzpb(7jmWzwzPHgJ=oL7bp2V#Sqzk`e{z6=x)_xZGuC zhLS1JH@0t+7ibYAmwA9bL0_R)d)u4l1zNyBk$z`pNl|Kn0J-T!SK#c-?97>&bH4MP zGkUPR96NY=H~+Ew*Yl3^H)_m30UE!?PkoMpJ8g%%+{@gyi?^S71HbJLf_5+n+u@+r zuDSF*$m)Zr9hrKVEezszJXmZmnszN)8Z5V$O}(D23|8B#sBiFyFFbeKYy2f1^F`Fo z@Fl+dCzr4A)#qM&ov-mT&z<&JzRu6$eU6{w=kY$zFYt?aU*O(7r}6U9pX2+zRIx$9 zN10&VBFjWqE7lX)P)N2r%DXx(a>bIIvu>6sB^1-WM6*k3nB UG$s3A5h%2(!FcZD1zxybdl;Hkv%%5(Fd zr@algtYt;Qg=~1`%2u(B14$+BB)Z!x>(aI`Xk%LpiUYxK=ePEge6P5E?W08I*e$-* z@5*A3D$xyTgVj^Ro7(TTnWHyovwJ zhl#=$e~cNPZJ|dpX9=6%J3H(ZP%Ehp=VLJBZfZ1mnCc$soJpZzAqKN_lg#LpgmJU; zrWS)?mT1wm=Wa@o O!iz)-E$pws-WQ%g`c+d8n(kDr^a(Swd zPL3Uwb)(nEx?HLh+|lEqC~H_xkCa>`S$0gWzjEXT+Ar?50Qf$9qbpR)0^}C(($aEl zmEOwIoz`%ydqsY|`DRO{T3p5GezJ!N)ezMyr0$NO $lXtaCpGO&Y7>7F7_fPA5rZU&Zumx7 za-BMie(K}}pNyb-d6qiQQ2_>Y ^$VOUpMl!q7cr@cexLB4!jB!xGtEHyW4pMQ*2#uR;SSXe5 zWMk`-vu)mFk04ROc@1BY=&8gJJl1TSq%k^pHRvjkRAdLj?2@FPS{3@(1h=H!-U(SO zQCEp$Dox3XPgz#L(GeypDYumZO5myFPK8Y580%W kIEo=N@{1Nbl$`<_t6D z{@qB(@jU@HmQc=}B!|ySd!AdPZl8f&KwU(aiHW*55p~Bl>Q**4NFoal1PFw)D=>vw zg8)|S>?62!3fVzGY}iE}As%QUPfcMoJWJK_;6b|A(~K8J7 OG8 z!Q6?~QvMJMD1Ag0xN_L1{NS`+mpil=XhV*b&~IbBG7J^PZtTj-XrE9o88pJr zIKD=O)ceeR;%j%}lbY4f$@#Spg _^+z*}vy2iapZ~>#Ax<@M$f4@#l_nG?< zj1f3!NBax?SmrKlh@cyD-}Ei+FWEW22fcjk@PLAD^6`{R9w5Hr1PE%zeQXd$a$}Ue zNm`Z(B0daCff<^w!WZ0urMt$#>{z2(UcfQ(LSqorU-^sC8yh5JVgUey2xN1L53|HE za?G+#_6{h+=2w=WjPMyHm~5>t#*}*<^BHP_5hW19$j0_q#x&JVK1ln*LT$QY(+t9H zsyy#QvjJr>O`?=NKWe+6KCFQ3FgM#Na#5+tBqqfu2e}asl|F (D-f+rR(G@)}i2z$WYZE^n!7rcz@ 2u3lX;WQXm z35;_G*uiKE#ppB?*W7@h_zR3U0Yx7jGj4y1#w>KMPn<7Y3Y;@;e@){`1fbcT0Brvj z#)RDa(xuux=V(oX`3aD8iLxB8>)`iE#qSZ#m%C5F=o6=3myda9-%lOO^d?Bxk~>qT zpT%j)2IsTGX}&Y1DkLrDGE^b({{L}SD9x>u?uC>YPBR9A%6z(uRLE<#j{Ih`)$opK z@P*qd-DYFKP_cXyfUtfaxvLT%cytC`mW_Hz#RtRD(x4Me;tqEhB3%7uEK~6Q8I5he Ybsf}mE{Kn_ZN#- Xky7-^5d0w NVdZ?Z9BoAB{|(sZLi7Lt literal 0 HcmV?d00001 diff --git a/trydjango/lib/python3.8/site-packages/django/apps/__init__.py b/trydjango/lib/python3.8/site-packages/django/apps/__init__.py new file mode 100644 index 0000000000..79091dc535 --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/apps/__init__.py @@ -0,0 +1,4 @@ +from .config import AppConfig +from .registry import apps + +__all__ = ['AppConfig', 'apps'] diff --git a/trydjango/lib/python3.8/site-packages/django/apps/__pycache__/__init__.cpython-38.pyc b/trydjango/lib/python3.8/site-packages/django/apps/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c28527179965217a757bb628780574dda7cc27ed GIT binary patch literal 281 zcmYjLyKVw85VU>AQ}7owSAdH&5kiOvY8ps$jpblt9DHZXz6jkX@k?$~ 2!=BF3aC@3H3XX=O92fkYNTOkiZ62xWqX1#E>d0Gw3ssD^lj7cR)q| z2ZOZ0arEZg*4AgOfaKh{;L|mq0ql!j?4P=2H;h9sl@5(>yLB8e#*Ja@j{G2b68s(M z&H8I_{3HY2eezn_ovbVcm*^NZ`h&W*x!C$;@k)bk
i)i6J|rjCg2ZAU-|l|XU^~w^a`tMbF0g^-E}zQ&I_ySa+iDfdWN;G zFKRsC^%vH$4HnPyCEk2tckBEDU*T_|*5EDvHt3i5DnEyBlds_z7pwZ_aA??^e0VpF zl?tU8N})tnB-vgVhxZQRY%dSv;V?~lagpR%7-u|83KjOI$J4!?9 A@^NV$cqjf#>aFQs54}%H>m(>a zkKVdotD(y!ZsAD&R^_Gfu1G7p^NL~Ts`*UF-CT(%iwB}|hjFprZdR^tk@%su%EkFq zRfBHgqL5WX4r5s)bXr-XH9Ry@AqiyF+Yv1h^<_SoYF#c-|FTi#tj|MV+o@b7(tZ_S zeY1aqYG&83EqM_{|M`65c`gstFzyMpVdQ;J4DyXaj=7fpMw;wy49CTOp1t3>xuKFm zTnF`GyoU)>5<0+!(MV@Fu7W5^vZRQjW$d6Xps<+l;#X_fEvI2OUA&&}PF6Q(0O-u7 z^lT!ZK2)D;aup2@xgS^uRI)z1Kr&}rli()teI(CljBUZ4I z9ow88I`W|&akzWz962SvhjsZ;;T*UpUg^BF_duOBG2f>dXXd){pr~;V=+$REw!gBo z)sm?ay?$x;?F%rtuQ1AMmq-%9 yxzJ5}L(S7iHk zIL=3)Q^nj~MOf@7ig*g2CtxGa!Z`>+xF)T<=}@>%46TQzkBlSP9TlQ8IsR^jvi!SP zx%U5ILXwo)LFJ~2DyrI^D75uDsmLmpD`S>5o=9!$juM3=D7Re$Lo$uZqw}dMAVCw^ z8{m`#`48}_t0*kLWjFB)?3PPkW;5phm%a8~SJz$CU3YSMF3!%ke8m|M*Rf=PSA+N_ zPBQ@vOAW!_SXsvfqz@bNmTl3G1Ez45j9lgK0OTY02=G-Od}aOC%I-X|CXJFEI7c>S z{tz==%;aWfN$!^&Gar=O))TbOu7W+uWc FG7 fb~syr D;sVcqb7Vg=$7YcHpP@TjHU98w115u^$3OKF}KN99GA6VA%VkK!(L%6 zv;x@63VwmpU;$zgv;Ehu$83!2dc$R~uNGOA%`E(0yRRFyNo!$QW~-fVr5$s7`U3lx zOtvUoo!Bp7K^Y;^I$>0wP(QGG;=Z&l0qxs}D1`@`c{IhGuLE5TP98yyoV>vtC$u?} zKg<#GxhO_5gZ2dZW|11lNzJ|FnaILkti<&sLq>(TjUGd#rP*mLR*4fO!iRZ&I2vl5 zg-JhzGc`+!FX7 -E9u~TgN^ctP5b|6 vqOJ(6N8GO7HzkX7(2G1g2~OQ$&0A-(NrU)pWx<@Bk#%ThcYB~qBR z-^55AZrW`A7i^)(zgoU)HvtU>g_HW5uP5ggik{OyIHPMy0LUbIc-2QJ7J5dFoj5P8 zd)Du-QouiO4?KCbwAIz8Yr5sj8wlbzsPzS~@N`Wl^(_7~T<}6AMzQb`$hTy?izo|w zH)1=bxsS()^V$NhX%O`D6jGz)*^q{@6y!FNte1|s;I|e^zaGY;BEN2s%xCodT!w=< z8(+r|eUXu;I>j~s$VbJT#gN>Z_>xldgm$2GL+}I+FD!`RYjeu$v(>dz)ack1K&N^R zoeLgf)l+BM7RX FwZ!h=TMB1sB#==Z#00bpcH3Ej<8ogI~`nOZ+|YMnL`GA z&P;?iHZtLPPp>5SZQ5_VE(x?lnLMK-Y(DyAf$^<&O~Y6I6sk7p^q9#A2WHwIG@5N=W}Ei0VM_IzGL!jPsa&F1!AS! zh|_dx(Ap}sd?Z PmuOWE4&p*p=<7{sWtz{$=Wv7h1ECKC>H zQL+jR@8`I70 z-deD)$8gEtX|o3p+RO4X$f`y(6HZh$qv+` OSI7ss37lFE$QUh zoIw7Bx+$TQx2U*7#m}jrtKg}EZbmvx)16b%wJES&7F-RS;4;GGFB`4K`Jk>T+I9J3 zj8}CdZd?|%Ub`2})vyCA79H_rPYmfot90D&UY-t)iX>GXXdTz!D9vNCbc3ARGY(F1 ZrI|FBwmW9dhonVCOa}1bNQ#;3{12Z3nhF2_ literal 0 HcmV?d00001 diff --git a/trydjango/lib/python3.8/site-packages/django/apps/__pycache__/registry.cpython-38.pyc b/trydjango/lib/python3.8/site-packages/django/apps/__pycache__/registry.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfcdcf64a08c4949ad1300efe5f3decb987d49e5 GIT binary patch literal 12982 zcmbVTQF9yDb>3Ypzy%0Gltj~#96Kw;js!=7+}KGPN0qIJR_az}9f`IRG%B*hE=hm@ zmb$wTMHFggBDGP{ahi7e(&@BAwNL5~=xhH#AKKTQ^r;UWzjQj&nLcDXQNQop-336> zai)}Ucd@wl?!D)p^PTUUd;P(}LdC$})|>ycadpKo{+(Z@{|fl>Ha^jP6u#k`J)^0w zX491KR@0Jep;^Gy>e>Bbv)C^+OZ~a#oXNU{p3!%jj@;Y5a=+57^yi!N_+Io&y=s4< zxnLUKGW {s~GIu>34&p#1^S`J3Kn4Cv zryVErez4&Ud$Er%bu*dU@l@RLdUY!~d2MIsR ?eC~?Cs4h; z>)~LdvpGaZpO| I==O#HH6@a;!t)AnEUOa2`0 zioWBQ9~sS(U-9R0o%5^y0 r~FHP1J~1j5kh`Fu`%^%^p_PEf7e` 8@paF3f=7>*g<>cwYS-( zANoNry66Ut&4wF?E*9io#}Dw RRx7FAg06S^!8=NYN>Te1C!JIv z?3NZ_GLL>+dPSn-gshU!cjeD2d~r*O;#YN}^jlFsEXP~C=?pfL;;oxudpjw%dc4f_ zLjBn8!G4mHt({=NYAu?MUYx|)33rBAsQ|WSM?r5RspZ-rQgFHj7`ZUEU4VcC_QQ zgXr=~*BfkxD?vZJ4Ab=G+vQ$o{qoLUycG^!Z~W%vs1pa5P ffd_hD=tC{ z*T&X^!k`it_e*2ziTR)~E_CP6o3mX~_v5l}^ZPO^_=n~gI@fjh{R-YUF0?9l-;RkB zrAK_fvtNB;tf1yY^MS1ab8PP~=w}a# ~@Gt)Zt5!w-HD)KnePeVQLrM z^ A3=(rh#zX_*nsHGvDq~~r0C%{ZyQg|)u(1+)8e06iPd-w)}34L z#CX(Mv`@-cHiJQMe@9(yvri&|ZCb|271hpW(zpWi1?FCDOsY?hix|SDx7o+%P!J05 zEPc; mEk>88 Uj?842u_797mBj1)gfP zp}m13@Fd4JgLoQz>m~Jh_U`h>BDHT%UEqC5gcl{1iTWInq w8@Mn4yH&JfR+4WOa1Ul4cbiqi%vZd>XN zV59{XU0gQ4hB`p<5AVJa!?kn8ziSLExW@tnVvqhRcQn6RGL+JkINXg8%oR*~vjdaS zj%Ui_X=S<@hTFp(p@uHZY!I@8Ozbd0z;NX5cH%Ac1P3XoH*tKUv#a5RoXWeUu2gf+ zzY?8qj83{M9T+G{ZGiFd;ajWqxyeE$&hG|$nw)ZF#4o7JxJ%}zMpw5*F_SXJ*OLCh zb%Q7Zs}nFhu*gYmb~S&7{=|D4B?o9$HEX7WvVtqLm+@WHm~8 8AS~auu&Y;~J0{Pz5ffNbTCD$9q;U(?L zGD0Ql()R{?m+%v>li*1dARNZ|SY3_JRFn>g6GQ2K;CJ8{-I#WHF|T z6=?z< zxzS J*D*pd*?4k>R9E7>9>e(N{JTk~^^cZ&rjty78`9re33_$a~z?_-M z5Hy5XAWe9yi2^eh;)j7m3Lqb`2k8X&y>^UvKO6-3Z92S2%m&bCK?Qe*9TjNz3j`J2 zroT&y5r!43YrHSXG$Qpnzm#(oPc>Y<#mAM2bk)0faHJyN#1H?7PeejuRBa)Cj#;xR z7QoXQ)vjfrDZL%SNKz+J=bzwaY;}Q*f{%!7Pa9O#v5m;JhhK0vMy{n>fLlbA+XZ6E zcbnhiVz)#`IxcKj%SJrsTTo;0#=)uBVa$tPr1sd_u+!+*;uA)``(;MTjJfwKGz7`C z6jw(-d5>g>zNi6r 3OBq8KISQlCfCr60tedJml{uA5p!kyKj5IYhij2RXZ*8ldASv3Zx& z()7?r`mv6Cp7X;a@-*rVj#WdYR-~fLLSEODh*Qt%kTcGts^Ruu(M|L!3d3dq;+TtO z?U}_u!z%sKDp-c~zfOrk2cAB&B}hqK^lU#f42^Omg3?t-FQdrNGd6!@Y=BAo)+69( z*V0^!$q!&*VYHvy>~&IkcXulQ?x~bZ<+7e|Ai;waB~nn!Gf5L4ON7(Nq0^lkL%4H! z0M1HaMFpL zEzybTcYK$3d{I)J?(sjeH >@)o){MW;7N8li2n)mz!CV7;D#s_02=7qNPas7J9)zh(8iV-$9*&0ODNfdHr?Y zy9zKj{u>nx$*O72K9ToS)?`Xw)20B~0;pu&nS>sSF`_`PiX&RM4nF>XPfHLWsA5uz zKxqO$g}vtd)XF6lV87q-!FwZdp~+k{T<6Li9RF$h;UmZSUwD`Huw}<2RjisP%q5hz zIeJNK;!~T>cw9msKiAnGrv)J+!*UwL5$cWDT4#(kePpJY5eYr2&KC<5{#y=(w>$k# z&qMeax;cZmP}fP&jJKq81R4V}lUl$OdCL2uM(Gd~64jyG6n%R)J|DS~aK*dGn$REI zEWFrO2oH MzXtG9grz@o8fN$F0@<^Xn0vp%AZov(TnfRxP6_?&D6R9 zIHSi*3YanSd*N=N)Kxr4BTsR7+Od9!rw3PfiE_%^Q{Zby2b!XF-f))S<}9=F%(h0S z^JP6)e+KfnnuK~;QNEHZN;mc~cLr9NWbI;?iYW#48hH?)>@|4?4{E}=^u4OeRVN+v zefs;|s!lL?7Q9L>!W$sP8ElC+$EKa4NH54H+c`u=Ta6E*K%Ij=q$wG$#guQ$` zG3akNnQo#l`>ZoU)E76stb>zJb_g#Ubyf>)}Vy4*;!vd~g-YOprp=?US)~56c zZTtYEg2krfyr+gb_X@>ndqaR^hZ>2!DWp#j2DgL!{cVNV11d_2z#J6PPRuQ1?ETJW zx|P*%ZzEXL+L@2c&1de1$ofw@+`{e^n7{`3rn@4WS4iO@%c4`2lxo&eVtj?cang{Q z7h%&>TW8*#wuop4o(3UO-V{beUNJ;)9%5Hi$fCa4MA$L0k2PTL4X7Ejqbs q)^1hV<6j)#a_7Q#qgOsUJtCt#y%|Pi5a~K6vTe}zWo@MatipE zVxiIH4x7=PBO!<#A&(>jB#(3ZW!;b71 @QsWi3*R81Z(;fG zR5VBa3)zj*`uQ?`Q(t6pKwZmMAPU)hdV|VI94?U*zbd$WSWHt?BWpN%>sr2UvebH0 z5EwUHN1emE0M~XOyNaS04C&NGyme+?RBe8Q`E%@;)#tL^wl35i!F1}>kBkD+T{k9H zg{vSIDCfGNMR1nCF&MbQdDEV3 rYZ7HrI2rXcWl4VbvPNZj?R3>>6^<} zTbZiO;v@@BEh$2=`;iVa3wk3W KBPhYWPB>)F ziex4{(g+)?z)wmbDS)YH2{5=mYQG{`I?6V`$yri04Pa(UDUPZ)1CyC;Tt~C$779{| zDBowoH$=xM5jz3;igLsS@sb>CDM>jeC7`fHPz4z3 t!O9h@P6bQ<2LQIuKM z3?v7^Zc3YxfdX4*Y8*d%zK`&4H%lf#HSxL}L^CeUVNi25%4TdUYPf4#0aIA`2`PcS zEF+pXqa5 y`(bCsh8V)@*u&vGX*8y@gVf^@U8 z{1!1lxYO|x!V7L`;mlID8GBgA51|`DSFnJ|IAQ^564A{!#m);-+IUigwU;D?s`sKl z1Mg 29r@vdKfPnuJ^+hm^zJSMQ!l_h-ksx?bl|4sAW$6QkL-d9DLy zNWP?lTIK^8G55&&Y4AY2T$`q_LaZBnpDE;wbxlBkyoY~e?eAb7l N z<7u)@Ql5>GQ@>*?s*cTvklbL4yI7||x|zynR?fo4>5q}6{gL@2YXg+rFFta9jO4{* zc$rb{F~Zz&;iuR#_{bQ%Z0jBNu8E#Z1HU2sMUn#~o<0lv=9TY&3yqQS<6$)T=92e) zj6PqYHE$adcQ=Lu;ih8eo;w)!*EIrPI7bI08_ee}y5|HkNUP7)-57_oxRii~ygLa6 zb=HDMTBo-yQ?!}vdCp+V1b`;^q!|M=A|G9vb s`(D9 z%f>`J6$DEF;I( R(}}=!yMy0Cn(l(ktA$KjRG(0Ao&4jr`09+k zWsHM57`Z4Im|;DQhd2U+)dOSQFdv(LYyA|f$?X}P5iBSwP-0UM$x_c7?dgQd TM>kEz{4rI2 #|_ZNWI9SjUvq(CQdd)99w4=N(9)f%np;!WsNoXKVT;^Or9#b z$6*pejf!nLbIZlWLJ7MhHT+x7l1fJnd&Vv~%^d$EO^9=ZJimex=|IV)1OLX>rt!o= znn@0M!fs(rcV9}m?qBB`k{T08MQ`sCh%ZjeXM{lvi~7eX4vt+;XJ#_MjvG=b@YO)Y zyt7VBjsd{Kf3yTTVI4ig3-7te#gdxH>SV^F7ZvU$?}W(<<}IeOb+Q!nI$0u5P|jne zAF!D9v+4sp`x}Z{oJ(<$&gG1}^~gOjz%M(fo2zx}#*MnQx>i3Un{Mjcc$`#Qt-C|7 zM+Cv%+gz*VhwWBNo#Tt?@pUd*c5>zL%QZGCi=4u+7bWF9Kc#ar+>})xvG^W~O%|ec zJ>Csj?6TnhXrcC4h+C!p$jqi@J23(x`vN{u0|m0srONrrHK*bf@$Uo<2cE3F;4C|3 z=cH4sn3d<87x4VFQ*sua^NMXD1DBUY^+Q|~8Hr-Nq!?nrA>m{Sb5htDl@pQ@>*<5& zv~v6p1(N#0DLfT4a@HKlc{Dj($%BsE;gBPk@ . + self.module = app_module + + # Reference to the Apps registry that holds this AppConfig. Set by the + # registry when it registers the AppConfig instance. + self.apps = None + + # The following attributes could be defined at the class level in a + # subclass, hence the test-and-set pattern. + + # Last component of the Python path to the application e.g. 'admin'. + # This value must be unique across a Django project. + if not hasattr(self, 'label'): + self.label = app_name.rpartition(".")[2] + + # Human-readable name for the application e.g. "Admin". + if not hasattr(self, 'verbose_name'): + self.verbose_name = self.label.title() + + # Filesystem path to the application directory e.g. + # '/path/to/django/contrib/admin'. + if not hasattr(self, 'path'): + self.path = self._path_from_module(app_module) + + # Module containing models e.g. . Set by import_models(). + # None if the application doesn't have a models module. + self.models_module = None + + # Mapping of lower case model names to model classes. Initially set to + # None to prevent accidental access before import_models() runs. + self.models = None + + def __repr__(self): + return '<%s: %s>' % (self.__class__.__name__, self.label) + + def _path_from_module(self, module): + """Attempt to determine app's filesystem path from its module.""" + # See #21874 for extended discussion of the behavior of this method in + # various cases. + # Convert paths to list because Python's _NamespacePath doesn't support + # indexing. + paths = list(getattr(module, '__path__', [])) + if len(paths) != 1: + filename = getattr(module, '__file__', None) + if filename is not None: + paths = [os.path.dirname(filename)] + else: + # For unknown reasons, sometimes the list returned by __path__ + # contains duplicates that must be removed (#25246). + paths = list(set(paths)) + if len(paths) > 1: + raise ImproperlyConfigured( + "The app module %r has multiple filesystem locations (%r); " + "you must configure this app with an AppConfig subclass " + "with a 'path' class attribute." % (module, paths)) + elif not paths: + raise ImproperlyConfigured( + "The app module %r has no filesystem location, " + "you must configure this app with an AppConfig subclass " + "with a 'path' class attribute." % (module,)) + return paths[0] + + @classmethod + def create(cls, entry): + """ + Factory that creates an app config from an entry in INSTALLED_APPS. + """ + try: + # If import_module succeeds, entry is a path to an app module, + # which may specify an app config class with default_app_config. + # Otherwise, entry is a path to an app config class or an error. + module = import_module(entry) + + except ImportError: + # Track that importing as an app module failed. If importing as an + # app config class fails too, we'll trigger the ImportError again. + module = None + + mod_path, _, cls_name = entry.rpartition('.') + + # Raise the original exception when entry cannot be a path to an + # app config class. + if not mod_path: + raise + + else: + try: + # If this works, the app module specifies an app config class. + entry = module.default_app_config + except AttributeError: + # Otherwise, it simply uses the default app config class. + return cls(entry, module) + else: + mod_path, _, cls_name = entry.rpartition('.') + + # If we're reaching this point, we must attempt to load the app config + # class located at . + mod = import_module(mod_path) + try: + cls = getattr(mod, cls_name) + except AttributeError: + if module is None: + # If importing as an app module failed, that error probably + # contains the most informative traceback. Trigger it again. + import_module(entry) + else: + raise + + # Check for obvious errors. (This check prevents duck typing, but + # it could be removed if it became a problem in practice.) + if not issubclass(cls, AppConfig): + raise ImproperlyConfigured( + "'%s' isn't a subclass of AppConfig." % entry) + + # Obtain app name here rather than in AppClass.__init__ to keep + # all error checking for entries in INSTALLED_APPS in one place. + try: + app_name = cls.name + except AttributeError: + raise ImproperlyConfigured( + "'%s' must supply a name attribute." % entry) + + # Ensure app_name points to a valid module. + try: + app_module = import_module(app_name) + except ImportError: + raise ImproperlyConfigured( + "Cannot import '%s'. Check that '%s.%s.name' is correct." % ( + app_name, mod_path, cls_name, + ) + ) + + # Entry is a path to an app config class. + return cls(app_name, app_module) + + def get_model(self, model_name, require_ready=True): + """ + Return the model with the given case-insensitive model_name. + + Raise LookupError if no model exists with this name. + """ + if require_ready: + self.apps.check_models_ready() + else: + self.apps.check_apps_ready() + try: + return self.models[model_name.lower()] + except KeyError: + raise LookupError( + "App '%s' doesn't have a '%s' model." % (self.label, model_name)) + + def get_models(self, include_auto_created=False, include_swapped=False): + """ + Return an iterable of models. + + By default, the following models aren't included: + + - auto-created models for many-to-many relations without + an explicit intermediate table, + - models that have been swapped out. + + Set the corresponding keyword argument to True to include such models. + Keyword arguments aren't documented; they're a private API. + """ + self.apps.check_models_ready() + for model in self.models.values(): + if model._meta.auto_created and not include_auto_created: + continue + if model._meta.swapped and not include_swapped: + continue + yield model + + def import_models(self): + # Dictionary of models for this app, primarily maintained in the + # 'all_models' attribute of the Apps this AppConfig is attached to. + self.models = self.apps.all_models[self.label] + + if module_has_submodule(self.module, MODELS_MODULE_NAME): + models_module_name = '%s.%s' % (self.name, MODELS_MODULE_NAME) + self.models_module = import_module(models_module_name) + + def ready(self): + """ + Override this method in subclasses to run code when Django starts. + """ diff --git a/trydjango/lib/python3.8/site-packages/django/apps/registry.py b/trydjango/lib/python3.8/site-packages/django/apps/registry.py new file mode 100644 index 0000000000..e01352b1de --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/apps/registry.py @@ -0,0 +1,423 @@ +import functools +import sys +import threading +import warnings +from collections import Counter, OrderedDict, defaultdict +from functools import partial + +from django.core.exceptions import AppRegistryNotReady, ImproperlyConfigured + +from .config import AppConfig + + +class Apps: + """ + A registry that stores the configuration of installed applications. + + It also keeps track of models, e.g. to provide reverse relations. + """ + + def __init__(self, installed_apps=()): + # installed_apps is set to None when creating the master registry + # because it cannot be populated at that point. Other registries must + # provide a list of installed apps and are populated immediately. + if installed_apps is None and hasattr(sys.modules[__name__], 'apps'): + raise RuntimeError("You must supply an installed_apps argument.") + + # Mapping of app labels => model names => model classes. Every time a + # model is imported, ModelBase.__new__ calls apps.register_model which + # creates an entry in all_models. All imported models are registered, + # regardless of whether they're defined in an installed application + # and whether the registry has been populated. Since it isn't possible + # to reimport a module safely (it could reexecute initialization code) + # all_models is never overridden or reset. + self.all_models = defaultdict(OrderedDict) + + # Mapping of labels to AppConfig instances for installed apps. + self.app_configs = OrderedDict() + + # Stack of app_configs. Used to store the current state in + # set_available_apps and set_installed_apps. + self.stored_app_configs = [] + + # Whether the registry is populated. + self.apps_ready = self.models_ready = self.ready = False + + # Lock for thread-safe population. + self._lock = threading.RLock() + self.loading = False + + # Maps ("app_label", "modelname") tuples to lists of functions to be + # called when the corresponding model is ready. Used by this class's + # `lazy_model_operation()` and `do_pending_operations()` methods. + self._pending_operations = defaultdict(list) + + # Populate apps and models, unless it's the master registry. + if installed_apps is not None: + self.populate(installed_apps) + + def populate(self, installed_apps=None): + """ + Load application configurations and models. + + Import each application module and then each model module. + + It is thread-safe and idempotent, but not reentrant. + """ + if self.ready: + return + + # populate() might be called by two threads in parallel on servers + # that create threads before initializing the WSGI callable. + with self._lock: + if self.ready: + return + + # An RLock prevents other threads from entering this section. The + # compare and set operation below is atomic. + if self.loading: + # Prevent reentrant calls to avoid running AppConfig.ready() + # methods twice. + raise RuntimeError("populate() isn't reentrant") + self.loading = True + + # Phase 1: initialize app configs and import app modules. + for entry in installed_apps: + if isinstance(entry, AppConfig): + app_config = entry + else: + app_config = AppConfig.create(entry) + if app_config.label in self.app_configs: + raise ImproperlyConfigured( + "Application labels aren't unique, " + "duplicates: %s" % app_config.label) + + self.app_configs[app_config.label] = app_config + app_config.apps = self + + # Check for duplicate app names. + counts = Counter( + app_config.name for app_config in self.app_configs.values()) + duplicates = [ + name for name, count in counts.most_common() if count > 1] + if duplicates: + raise ImproperlyConfigured( + "Application names aren't unique, " + "duplicates: %s" % ", ".join(duplicates)) + + self.apps_ready = True + + # Phase 2: import models modules. + for app_config in self.app_configs.values(): + app_config.import_models() + + self.clear_cache() + + self.models_ready = True + + # Phase 3: run ready() methods of app configs. + for app_config in self.get_app_configs(): + app_config.ready() + + self.ready = True + + def check_apps_ready(self): + """Raise an exception if all apps haven't been imported yet.""" + if not self.apps_ready: + from django.conf import settings + # If "not ready" is due to unconfigured settings, accessing + # INSTALLED_APPS raises a more helpful ImproperlyConfigured + # exception. + settings.INSTALLED_APPS + raise AppRegistryNotReady("Apps aren't loaded yet.") + + def check_models_ready(self): + """Raise an exception if all models haven't been imported yet.""" + if not self.models_ready: + raise AppRegistryNotReady("Models aren't loaded yet.") + + def get_app_configs(self): + """Import applications and return an iterable of app configs.""" + self.check_apps_ready() + return self.app_configs.values() + + def get_app_config(self, app_label): + """ + Import applications and returns an app config for the given label. + + Raise LookupError if no application exists with this label. + """ + self.check_apps_ready() + try: + return self.app_configs[app_label] + except KeyError: + message = "No installed app with label '%s'." % app_label + for app_config in self.get_app_configs(): + if app_config.name == app_label: + message += " Did you mean '%s'?" % app_config.label + break + raise LookupError(message) + + # This method is performance-critical at least for Django's test suite. + @functools.lru_cache(maxsize=None) + def get_models(self, include_auto_created=False, include_swapped=False): + """ + Return a list of all installed models. + + By default, the following models aren't included: + + - auto-created models for many-to-many relations without + an explicit intermediate table, + - models that have been swapped out. + + Set the corresponding keyword argument to True to include such models. + """ + self.check_models_ready() + + result = [] + for app_config in self.app_configs.values(): + result.extend(list(app_config.get_models(include_auto_created, include_swapped))) + return result + + def get_model(self, app_label, model_name=None, require_ready=True): + """ + Return the model matching the given app_label and model_name. + + As a shortcut, app_label may be in the form . . + + model_name is case-insensitive. + + Raise LookupError if no application exists with this label, or no + model exists with this name in the application. Raise ValueError if + called with a single argument that doesn't contain exactly one dot. + """ + if require_ready: + self.check_models_ready() + else: + self.check_apps_ready() + + if model_name is None: + app_label, model_name = app_label.split('.') + + app_config = self.get_app_config(app_label) + + if not require_ready and app_config.models is None: + app_config.import_models() + + return app_config.get_model(model_name, require_ready=require_ready) + + def register_model(self, app_label, model): + # Since this method is called when models are imported, it cannot + # perform imports because of the risk of import loops. It mustn't + # call get_app_config(). + model_name = model._meta.model_name + app_models = self.all_models[app_label] + if model_name in app_models: + if (model.__name__ == app_models[model_name].__name__ and + model.__module__ == app_models[model_name].__module__): + warnings.warn( + "Model '%s.%s' was already registered. " + "Reloading models is not advised as it can lead to inconsistencies, " + "most notably with related models." % (app_label, model_name), + RuntimeWarning, stacklevel=2) + else: + raise RuntimeError( + "Conflicting '%s' models in application '%s': %s and %s." % + (model_name, app_label, app_models[model_name], model)) + app_models[model_name] = model + self.do_pending_operations(model) + self.clear_cache() + + def is_installed(self, app_name): + """ + Check whether an application with this name exists in the registry. + + app_name is the full name of the app e.g. 'django.contrib.admin'. + """ + self.check_apps_ready() + return any(ac.name == app_name for ac in self.app_configs.values()) + + def get_containing_app_config(self, object_name): + """ + Look for an app config containing a given object. + + object_name is the dotted Python path to the object. + + Return the app config for the inner application in case of nesting. + Return None if the object isn't in any registered app config. + """ + self.check_apps_ready() + candidates = [] + for app_config in self.app_configs.values(): + if object_name.startswith(app_config.name): + subpath = object_name[len(app_config.name):] + if subpath == '' or subpath[0] == '.': + candidates.append(app_config) + if candidates: + return sorted(candidates, key=lambda ac: -len(ac.name))[0] + + def get_registered_model(self, app_label, model_name): + """ + Similar to get_model(), but doesn't require that an app exists with + the given app_label. + + It's safe to call this method at import time, even while the registry + is being populated. + """ + model = self.all_models[app_label].get(model_name.lower()) + if model is None: + raise LookupError( + "Model '%s.%s' not registered." % (app_label, model_name)) + return model + + @functools.lru_cache(maxsize=None) + def get_swappable_settings_name(self, to_string): + """ + For a given model string (e.g. "auth.User"), return the name of the + corresponding settings name if it refers to a swappable model. If the + referred model is not swappable, return None. + + This method is decorated with lru_cache because it's performance + critical when it comes to migrations. Since the swappable settings don't + change after Django has loaded the settings, there is no reason to get + the respective settings attribute over and over again. + """ + for model in self.get_models(include_swapped=True): + swapped = model._meta.swapped + # Is this model swapped out for the model given by to_string? + if swapped and swapped == to_string: + return model._meta.swappable + # Is this model swappable and the one given by to_string? + if model._meta.swappable and model._meta.label == to_string: + return model._meta.swappable + return None + + def set_available_apps(self, available): + """ + Restrict the set of installed apps used by get_app_config[s]. + + available must be an iterable of application names. + + set_available_apps() must be balanced with unset_available_apps(). + + Primarily used for performance optimization in TransactionTestCase. + + This method is safe in the sense that it doesn't trigger any imports. + """ + available = set(available) + installed = {app_config.name for app_config in self.get_app_configs()} + if not available.issubset(installed): + raise ValueError( + "Available apps isn't a subset of installed apps, extra apps: %s" + % ", ".join(available - installed) + ) + + self.stored_app_configs.append(self.app_configs) + self.app_configs = OrderedDict( + (label, app_config) + for label, app_config in self.app_configs.items() + if app_config.name in available) + self.clear_cache() + + def unset_available_apps(self): + """Cancel a previous call to set_available_apps().""" + self.app_configs = self.stored_app_configs.pop() + self.clear_cache() + + def set_installed_apps(self, installed): + """ + Enable a different set of installed apps for get_app_config[s]. + + installed must be an iterable in the same format as INSTALLED_APPS. + + set_installed_apps() must be balanced with unset_installed_apps(), + even if it exits with an exception. + + Primarily used as a receiver of the setting_changed signal in tests. + + This method may trigger new imports, which may add new models to the + registry of all imported models. They will stay in the registry even + after unset_installed_apps(). Since it isn't possible to replay + imports safely (e.g. that could lead to registering listeners twice), + models are registered when they're imported and never removed. + """ + if not self.ready: + raise AppRegistryNotReady("App registry isn't ready yet.") + self.stored_app_configs.append(self.app_configs) + self.app_configs = OrderedDict() + self.apps_ready = self.models_ready = self.loading = self.ready = False + self.clear_cache() + self.populate(installed) + + def unset_installed_apps(self): + """Cancel a previous call to set_installed_apps().""" + self.app_configs = self.stored_app_configs.pop() + self.apps_ready = self.models_ready = self.ready = True + self.clear_cache() + + def clear_cache(self): + """ + Clear all internal caches, for methods that alter the app registry. + + This is mostly used in tests. + """ + # Call expire cache on each model. This will purge + # the relation tree and the fields cache. + self.get_models.cache_clear() + if self.ready: + # Circumvent self.get_models() to prevent that the cache is refilled. + # This particularly prevents that an empty value is cached while cloning. + for app_config in self.app_configs.values(): + for model in app_config.get_models(include_auto_created=True): + model._meta._expire_cache() + + def lazy_model_operation(self, function, *model_keys): + """ + Take a function and a number of ("app_label", "modelname") tuples, and + when all the corresponding models have been imported and registered, + call the function with the model classes as its arguments. + + The function passed to this method must accept exactly n models as + arguments, where n=len(model_keys). + """ + # Base case: no arguments, just execute the function. + if not model_keys: + function() + # Recursive case: take the head of model_keys, wait for the + # corresponding model class to be imported and registered, then apply + # that argument to the supplied function. Pass the resulting partial + # to lazy_model_operation() along with the remaining model args and + # repeat until all models are loaded and all arguments are applied. + else: + next_model, more_models = model_keys[0], model_keys[1:] + + # This will be executed after the class corresponding to next_model + # has been imported and registered. The `func` attribute provides + # duck-type compatibility with partials. + def apply_next_model(model): + next_function = partial(apply_next_model.func, model) + self.lazy_model_operation(next_function, *more_models) + apply_next_model.func = function + + # If the model has already been imported and registered, partially + # apply it to the function now. If not, add it to the list of + # pending operations for the model, where it will be executed with + # the model class as its sole argument once the model is ready. + try: + model_class = self.get_registered_model(*next_model) + except LookupError: + self._pending_operations[next_model].append(apply_next_model) + else: + apply_next_model(model_class) + + def do_pending_operations(self, model): + """ + Take a newly-prepared model and pass it to each function waiting for + it. This is called at the very end of Apps.register_model(). + """ + key = model._meta.app_label, model._meta.model_name + for function in self._pending_operations.pop(key, []): + function(model) + + +apps = Apps(installed_apps=None) diff --git a/trydjango/lib/python3.8/site-packages/django/bin/__pycache__/django-admin.cpython-38.pyc b/trydjango/lib/python3.8/site-packages/django/bin/__pycache__/django-admin.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c6f94ac2f3d4bf137392d73cb6dcba7af7720ece GIT binary patch literal 291 zcmYjLu};G<5VhSPMJ@dRBnH+DjRzKl5Mt=ef)G*`%Z;zCo17ilt{@wq0wceam5Co< zVB%6b@T7ZpPxtin9_RBZBW$m~*RQlcNAVwm#2rn%ATrGGmLab=XCRDdL^ucjHhE{9 znaKkyvM+M6f)7*FPHzCgr6E@ewRK9}7g;qkJMA{UtbKqmhL3Nj5tORV;05Y^0<{hv zRqc^NjB2fe4;D_yd!U~u`RqdzJ6%JR%R}4}(90D1zi`>wmF)Vo_3pB~lF=qukh`Hm gQ64QT>yGC_8?>(M`XRqTZ}u(Rj=f?=bSiTG3#SfIX8-^I literal 0 HcmV?d00001 diff --git a/trydjango/lib/python3.8/site-packages/django/bin/django-admin.py b/trydjango/lib/python3.8/site-packages/django/bin/django-admin.py new file mode 100755 index 0000000000..f518cdc463 --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/bin/django-admin.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python +from django.core import management + +if __name__ == "__main__": + management.execute_from_command_line() diff --git a/trydjango/lib/python3.8/site-packages/django/conf/__init__.py b/trydjango/lib/python3.8/site-packages/django/conf/__init__.py new file mode 100644 index 0000000000..05c603786e --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/conf/__init__.py @@ -0,0 +1,201 @@ +""" +Settings and configuration for Django. + +Read values from the module specified by the DJANGO_SETTINGS_MODULE environment +variable, and then from django.conf.global_settings; see the global_settings.py +for a list of all possible variables. +""" + +import importlib +import os +import time +import warnings +from pathlib import Path + +from django.conf import global_settings +from django.core.exceptions import ImproperlyConfigured +from django.utils.deprecation import RemovedInDjango30Warning +from django.utils.functional import LazyObject, empty + +ENVIRONMENT_VARIABLE = "DJANGO_SETTINGS_MODULE" + + +class LazySettings(LazyObject): + """ + A lazy proxy for either global Django settings or a custom settings object. + The user can manually configure settings prior to using them. Otherwise, + Django uses the settings module pointed to by DJANGO_SETTINGS_MODULE. + """ + def _setup(self, name=None): + """ + Load the settings module pointed to by the environment variable. This + is used the first time settings are needed, if the user hasn't + configured settings manually. + """ + settings_module = os.environ.get(ENVIRONMENT_VARIABLE) + if not settings_module: + desc = ("setting %s" % name) if name else "settings" + raise ImproperlyConfigured( + "Requested %s, but settings are not configured. " + "You must either define the environment variable %s " + "or call settings.configure() before accessing settings." + % (desc, ENVIRONMENT_VARIABLE)) + + self._wrapped = Settings(settings_module) + + def __repr__(self): + # Hardcode the class name as otherwise it yields 'Settings'. + if self._wrapped is empty: + return ' ' + return ' ' % { + 'settings_module': self._wrapped.SETTINGS_MODULE, + } + + def __getattr__(self, name): + """Return the value of a setting and cache it in self.__dict__.""" + if self._wrapped is empty: + self._setup(name) + val = getattr(self._wrapped, name) + self.__dict__[name] = val + return val + + def __setattr__(self, name, value): + """ + Set the value of setting. Clear all cached values if _wrapped changes + (@override_settings does this) or clear single values when set. + """ + if name == '_wrapped': + self.__dict__.clear() + else: + self.__dict__.pop(name, None) + super().__setattr__(name, value) + + def __delattr__(self, name): + """Delete a setting and clear it from cache if needed.""" + super().__delattr__(name) + self.__dict__.pop(name, None) + + def configure(self, default_settings=global_settings, **options): + """ + Called to manually configure the settings. The 'default_settings' + parameter sets where to retrieve any unspecified values from (its + argument must support attribute access (__getattr__)). + """ + if self._wrapped is not empty: + raise RuntimeError('Settings already configured.') + holder = UserSettingsHolder(default_settings) + for name, value in options.items(): + setattr(holder, name, value) + self._wrapped = holder + + @property + def configured(self): + """Return True if the settings have already been configured.""" + return self._wrapped is not empty + + +class Settings: + def __init__(self, settings_module): + # update this dict from global settings (but only for ALL_CAPS settings) + for setting in dir(global_settings): + if setting.isupper(): + setattr(self, setting, getattr(global_settings, setting)) + + # store the settings module in case someone later cares + self.SETTINGS_MODULE = settings_module + + mod = importlib.import_module(self.SETTINGS_MODULE) + + tuple_settings = ( + "INSTALLED_APPS", + "TEMPLATE_DIRS", + "LOCALE_PATHS", + ) + self._explicit_settings = set() + for setting in dir(mod): + if setting.isupper(): + setting_value = getattr(mod, setting) + + if (setting in tuple_settings and + not isinstance(setting_value, (list, tuple))): + raise ImproperlyConfigured("The %s setting must be a list or a tuple. " % setting) + setattr(self, setting, setting_value) + self._explicit_settings.add(setting) + + if not self.SECRET_KEY: + raise ImproperlyConfigured("The SECRET_KEY setting must not be empty.") + + if self.is_overridden('DEFAULT_CONTENT_TYPE'): + warnings.warn('The DEFAULT_CONTENT_TYPE setting is deprecated.', RemovedInDjango30Warning) + + if hasattr(time, 'tzset') and self.TIME_ZONE: + # When we can, attempt to validate the timezone. If we can't find + # this file, no check happens and it's harmless. + zoneinfo_root = Path('/usr/share/zoneinfo') + zone_info_file = zoneinfo_root.joinpath(*self.TIME_ZONE.split('/')) + if zoneinfo_root.exists() and not zone_info_file.exists(): + raise ValueError("Incorrect timezone setting: %s" % self.TIME_ZONE) + # Move the time zone info into os.environ. See ticket #2315 for why + # we don't do this unconditionally (breaks Windows). + os.environ['TZ'] = self.TIME_ZONE + time.tzset() + + def is_overridden(self, setting): + return setting in self._explicit_settings + + def __repr__(self): + return '<%(cls)s "%(settings_module)s">' % { + 'cls': self.__class__.__name__, + 'settings_module': self.SETTINGS_MODULE, + } + + +class UserSettingsHolder: + """Holder for user configured settings.""" + # SETTINGS_MODULE doesn't make much sense in the manually configured + # (standalone) case. + SETTINGS_MODULE = None + + def __init__(self, default_settings): + """ + Requests for configuration variables not in this class are satisfied + from the module specified in default_settings (if possible). + """ + self.__dict__['_deleted'] = set() + self.default_settings = default_settings + + def __getattr__(self, name): + if name in self._deleted: + raise AttributeError + return getattr(self.default_settings, name) + + def __setattr__(self, name, value): + self._deleted.discard(name) + if name == 'DEFAULT_CONTENT_TYPE': + warnings.warn('The DEFAULT_CONTENT_TYPE setting is deprecated.', RemovedInDjango30Warning) + super().__setattr__(name, value) + + def __delattr__(self, name): + self._deleted.add(name) + if hasattr(self, name): + super().__delattr__(name) + + def __dir__(self): + return sorted( + s for s in list(self.__dict__) + dir(self.default_settings) + if s not in self._deleted + ) + + def is_overridden(self, setting): + deleted = (setting in self._deleted) + set_locally = (setting in self.__dict__) + set_on_default = getattr(self.default_settings, 'is_overridden', lambda s: False)(setting) + return deleted or set_locally or set_on_default + + def __repr__(self): + return '<%(cls)s>' % { + 'cls': self.__class__.__name__, + } + + +settings = LazySettings() diff --git a/trydjango/lib/python3.8/site-packages/django/conf/__pycache__/__init__.cpython-38.pyc b/trydjango/lib/python3.8/site-packages/django/conf/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..914344254ddec06e036e88895f1bc7fce893e9a6 GIT binary patch literal 7421 zcma)B&2Jk?cJD7XDT< +dLMjKQT~-~rhf)*K0)DshsslI#Zx^kRBcsW zHCvNc-PYyRunk=Gu+%qgQ>DH}SngNsifos{g?`np%C;FU_G@-cw#(sCzi!w2%l0zv zEB4A~inriZUn*YJub=AnCEPE1HQd)uHG36zOI{s!b= UpiInHBZ}D8q1^qsP6kh z1kn?2xshje M?{2m~+jaI^oz8aqvwi2m?$)E7mgPs!0~SYpKN8jFE(_d)(7z)G zhA@mrV!d=gno09X7$3Ny!?P*=fyI4a%Ab4D92{3^vaS^dTv&0>a>LLX#GD5h0kckr z;?3&6VN;ZLLrsi_t~kVXc}^4_t!?)QEFSnQJiedl!}sv~+MeH!pZnf+lq%)JyMOGm z2)b)%Np;5^9q%3-`CXBe{Qf{3+gC1DLYHPR{nN7>{%2_T3JgUdBY}Zj@^sI5slr4` zp7~O-OJ3Ql;A;L@>8WzVD|T77X|rK8{sNxUR;zZ^U-Xu}m6yt?YS(_O7>d1w4PQ-a zG|_y|NB>^6@Y}RPJhZUrFOTJ>`vLZYS*dC=6M*hBLy?N^4!OW?O&-d%H>JD|EMv$a zpzB6f-;IXYjpM?$U@p0&0Sh2Z#OMt*($4mq)-H|xBH;cVDJ<1B$>VbCi;pwg8^l2* zV0n-N 9pEiZA$Otr&R8v@O!9)a-^PVLO)kew6VtTj#YNuQ^)ERCDJ_YL>Gpq zk9DE ebYp3d1aZJyEYD=SE%K4H)cVhSomN8lBg_EToQ!Y{1Y18T)2E33K za9VvTuoo~GxCr`FvR&p|k?(uHcgG5Pa$KqXLzhSIi$YB9+mJNTVYWG`f@tcaYWC8) z#gj_jarBct{~0`=6n%@|u?~h}B1DcKi^&FiP3wzzX!T(tR%S|`-wUGDcQ0Bogj%qK zF1c+!X0w>^?S^&W!@qsY?RI@QHEgBm)ozp%E#^r%lbh&Ie37iR+K;#QcH0kH?T+(! zb8ma|J3B2#`<+zwGxJL-&I{%a25@d8F}NT05+ic^ezKekchYT34A1A?R|;Fh_g{6^ zU&QPwAGnyxdTO0p0ETtJj#KPf4}*jC!Lc}uqYs-Ot@A+mAE5VB_X$48y3pFz9Vdta z;W&V=#3Ym(4iHfkzKTjQYpS8HsG6$j=6`Fi4RiF?wCgt0{#}*&W ~xs!gv=O{eyd>_h#STymfm{GYx+8 z9;4|tbheBOE2B!5=Wzd(%2wzlsV}WAQ@4uaFn_?Xe%$dIDn+Ye(O9x#z8+nko>?>R zJLAK&*kZvXrC9LVSUJba^aLN0o&o@(UR=wXc24P{L6PaSRSLF+7%P9uYx3?8|4 zr7_X%!cPNX1reTyJxs+5y0mSL(qz%>3WiV0usv4@Mr%tuK{0aem*};QA?CHP=s4L& zj`O?d#3j9eBC2W)Wpr&$4MpcJtvvrxo2;9z{M)F;;2Tdh20a`pXX?44Dp6gwp%qU% z*GMm?${BPqmUog5=%b$&Z~-rw)k?PYP3wN>yNI=L)h?-~U ORAfNF zlLfXaz))lm#L`aH6Md|m8RyED@`JTM)lQ6)5`v>XHpZn>T~(glL|buyKUlmz`c+|K z_hCa6*W!yv!gTngfaqKABZ#=eP!tyQej#b#G61<-itk3wDEG0lCZ @><(WOmLx0lib%@wfEYWs z%|rPmBe-F|PSqUfE)-F 6w+jiWzn?*B zhYbOnDIdWC(j?>1rOn7RbKt|hiy^#bLz`%aU4z{D$yX G<#EqPsLpz0--qj22~V^B`h# wS5ahOuc$_;dZ~h6ZLwCWEomyF_g$2kAFb^Z6i#v`X@RF9 z0nlY)piCzQP(8vty3TkoNv4o2cj^xKfq?&>s_@er6b#R_bA?qXK#nzG2!w)DO?qqv zVL@?9!aOTuZ%d%WNLNn`Q8~q4I}1V?>r%?YLP}d0@N#^A0$Myao|^1OqB<^#MN#YF zDgTjJ@-SjXo#lurIzaxySsg(LVEL?#yJh}!^o9H%Vh(33o^h_SUy4g-t6oXGB?H%* zxa^sy+Fz;cHu_(otGMcwfkWolJi12D&c5MQ&egwAPRe8R?Co;}eb&b1w8huNJKh5I zN@qhYasB9 Jw?V8O{!+RS;hj^UG4$NzE=23;`U92SylfWXg%8+HA}AXQ #pb7)rqPgmOB}r@cbyLyh!tKo*2|(6tj{t(jQ6148mA@p|ky<<=DIJ79-C} zDo4m02RH)&almXuV)|cVT%J@P(;0`vWJcJ=7ODCO6&y@bIpVt#lL^ui9XWzsm$NO_ zV=rYZb7Y*cmvS{bERKa;r(1CUUhMP&EOHK_0a$5XaDah0aYBmO6?IKFwVGxSIl*03 z!}Ya>H#N1cnQ8@;v8Ju*6?IizQ|mgS{H6U2c0pNFi8J6pdY~e~LBcp3?nrrR?klf= zoGSZ6yaXo8ML$4$ZlY`p&;Al6#bLybV!WCCc_VfZ4UvP=!jWQAPC_-(?7sy<5KCx} z-rcx$yBqQbw=PaQaOk4reV%>Xf+%*EDzd?gqKAa_zsAdy;~~v3RpWnVl$53;6s4u4 z-zG`lqH32aT5cK}CL1PO666VcT@+5N3E}jEik{*zZfAaacE|q&jR~*=)HMJ)o%qm6 zPkQ2$p7hYEPkz!v$9y>HNsssJh4f(0uBK-__M$xLsX>F6SOelm@1;yap6bX$fk_0- zeVaFD4@Sr&XpVA+C>|1>#qNN@B5lGxIoK!KqtV|K{3|;h0HLBRe&!IdIDE4R(~v_6 zoNZW=fm?KP04EJNogEg!zW#I(U(Zt?>ozDxe$qEZ#1QsDYC#D-fH)&+pK|3pXyrCd z?RlG~o&G6G%9Ts-qIcdTW?%15h2jVfNm=AitS;!hh;mP&%TOMBh}R(Wd$=U^&757P zs3Vb7&h34?o}VD`lD|ihcBUXhG}O_J3#a)1$P~%AX^us v;pkNb6KMQMKvykj_ct>}H V9sv^x_{- zGTqDk{NlMz5-K{B$$!))r4(}&iafqWM*gxQ)ISFVo~lB})i_nJBAq$~S(9)$gQ2;H zeh5+gI;t`9t`j7j_)vLTW=QcLgTp-2CJR;NLV=lD^KPQ@DSV`DNESAp_z}V~yZ28d z(?mt*FxA(i4=yw jX+_t++6q%QX{wWK{yIK6Dip^18v zw13P8R$u|EuSaix{lGK(Px_=ndnkit?scH1 UsU! LKk4}EnL#TI 36V7Mb859vC1s+OV84=R+KcIluRP6`yxG1|JYjy*|FY|+xx3`L z_O dfojFzQm?kA#|BR-V4HC2CRPC+UZrEnA@5$yy7o!&uWJ f?t5hB5=)E )bcx}q8S%6ID@)$jf<{#8r{ literal 0 HcmV?d00001 diff --git a/trydjango/lib/python3.8/site-packages/django/conf/__pycache__/global_settings.cpython-38.pyc b/trydjango/lib/python3.8/site-packages/django/conf/__pycache__/global_settings.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c014a6c64fdebb56ebf99f2f8d1963a32487cc0c GIT binary patch literal 8286 zcmdUzd3@u>b;n7HB1K8NT4~qowKuluICAWGMfvt-<2VLMP{N9r0dOUa;~*dhB(VYk z8UUpg;+%Hwqv?I$P1E#D?>4>b-uIDS?2$I<5w}gxG;N*3`ON^NC~fNeUGX#EcivoY z-n{n)V&mAc*%2vM(=2F?(>&-Hr{kanPA5Q%oR&Z*Ih_Js!|62W zT25y`*KxWYbe7W#KsRu@5p)x$Ea+xVF9hAf=|!MrPPc+y%;`4J?VMf$x`Wd>& >0O|Ab9xWxOE|q3^rf7> z4D{ukz5?`>oW2V5)ttTt^tGJ64)pb$z5(=&oW2S4&78gk^sSt}4fO4tz610=PTvW7 zKd0{keSp( Bm4n&Zx6ZW@(wu(1+*; zJ4rG}e}c>-I*-wxB**E8$O6g<`cq^Pk-B6g$w~Ut qZUm~~BUnaL>-It)> z9cVv?wiV2q!}luYxRd@0xeMQSquhh`dr|JAze<0tlOXrgUndWsoTtA*UJCgIl$W7A zi1Kp!o8%$-TjUk=x5>lwcZfiLm*na1kplgFQlx)C|B!x|{t^9S`X}^H>7UUd{d4*k zojD@XzodUfKhl{ZCHmL&Z|FzS^JDaH>EEIM-_w7fAEzJg%#$_x3|XiDNF?Zd5xhbF ziIkyV1*J;=nbaV!qdWpVWE2H^QRyd0gZ>M-ME{j+LbiqWZP=Dz?~l@dBd
EEv(w3&k_5*ab#l$&p7GhnIMm&w~MtstmmT)u>LMurpO+~T*3D~YDp5{ zIZa-J(|7`uBCo|WO A#cJngEEUVc@n*!Ld%;m%Ue+1it;v;x5G~F zfc%|U`(3ENn|?@%-8L7G#e%11i$+@?Sbny6S+_e*)-!zHv^!odTiZ2U*Q7?)?;4(w z-822}xHW6qOq}gGbYL0TzGK?HL9@Oy+uY|3#fw69t)?lWs!G*0MXS_`jk1_E>|N7! z?4Du!* RyW?Rr?{KuG;0*aT! +M2^evqLiZfz@GlL3`66vw6eP-GPTX zNi=Pe&Kq_|w^(1yn|BT0VI4g*IG)W%wRDm$=)P{TDOw(xE(Aua3*0Bun}+29sZLTw ztjO6QsWrpxVSy>?HG^YiXU}l6isLr ms@O&2v z>2`LqsnZM=@~-Kl>qw6A4#|jK-*9!?cTk1aN}sEN>AV%)4NeMf2cBWFon$B5T28Q7 za4e_ClseSXyAmu^j4L>U!*bgUma34tdS`H?Y1asrE*Z8F3}D>xC@6%}5j|Km-1q uq)Vn9ny-yxD7l8sEZp8lgKLJpIy#w_P=UNdg9WAKAgo}G zHQlh_3yF?JX4YW17N4_g3{&ey(>3;niLObe*G-$^kh?CKDY%aAqZ66xvg2v=VZejq z=?+L{eE^>bUB=YOoP z z!?n4rlbMS;js{^rOzfbxW;kw#E3u 9X$c@=9-q%vKQH&_AqO zBvXNB@1yicqGzM(AZdka_gs>$;J|%YFww(d 1XBcQ&t0)}-wuvNk}Rxg!fibmR@pNsSJB&J6}=06 zh6x|8s_H!x=I~(-)v%yBxJ#01S7#kCzdCSt_)y gu0Ko+c1WhN z bgS!lesD)P zEZ2e?=6bqm<(jwz44Zm6ujlu3B9rAq(J(U}_sn(hnPDurH5%S_+@6<1uv5cDGRPIV zGOB@H=)U0vC-;nI4>{g&C)Un98g_dudsvOOX&G4FcaWfrTnRO0A47XeC t@tA2s8W-NAF%>4KiUJFvy?B#RW?I06= zpUc*V@p>>-f(Vbx!E|qxu5Jfu{*|o z!x<)loCz64!u+@=ql2EPMLqM8aQ(t^<-)QO%q>ThTW$x_yb>&q^vRAIgHu (f5Iv%)x^}qws pChx1P!Vggv?f)DX&Szlk&I^` zAs_=%Gd5U?k*TtNCAejL%C_&C&0N&SJMe7U4DSBFI(c|?LCV9shnKsk)T&4oQ5{KB zC~Sz;Vz4qEjG$@ht*&t}H$tRm^m1jV1urbHHggMaM?pp(_}yFs(+9VYhldLCmT}ls z9BParE;zBOw_47?_Ptfh>6rFvuyi2lyAJdI)o0+9vEa@xG;3G)x@;%){6?{KcU|{9 zycW`RE)DMe;v uM81QRX2w4HkvKWAuBvryODiaH zNv+{HgY!q!!~7n53m#{nwr=4*Y3<}n5sVVibvP3oN(b4~ZkwGPUKjiV#~^n|Eow9e zot&b#4e?6L=(F4{8^|=shsaWR1~*6jku3e3JFu~}T+#GexYk^mSA+YG=m{&}vJLa! zC|N38#xkEbQu3bX8P>+T6mt(YAk49NdxK;m#YQnSvDRpi(C-&b*JvRtn}!z-y!}1H zw5Cy~rD^=1f#Gyf%s1A^_54e#%eA_&Ca9t&ZWYA3Dj~k`KR~e};d@@Hs-j#K%9>PH z$T6W@u5F4%ZM~+b3dyKaMbt>GD&ksIL`@}lUBbUn4Pi~x3bmq0GNY $V%UG-^mV`!G#ah^BRn^q(x;R`IOV 6R+;riT(8M0IT^~CMYt`PUCF{hXALd#s23Xz zTPezBO)idB;N~xn7i3jMDU+pe4xm;LWtDA%EFQ=<#BDB$)MU#-adI3dui~h2&_W%@ zo>9e0y$lb*{H2;)(PSiCQHDxOBTJR!S|u{bsc8O2{-Ribrm|R)w#YnY!YEBC3(7i~ zgOpb{H#f;5<}5(pf-Ke5@VHMGC1vDmZ0{P5s|t@hE##G28Mf6La#^e46lAFgwU(r{ zYE2gMIHh~3o~B00-kLW_nRZM@-VW3^GqW3wem zEEnONlM}Ne(29~wuAP+DMY$p=3J=+vCmYZc#%F3wc3EPlC#cbn8$9619F!2Xuz@VF z3XkeYFgICQ+!h5HgRAQLXuyfERur~Jl0{`5F0D<@dd-1oa=InnN2=BvYBU%J$vYgD zogOQ7SiV@2WP}1+yH?URMR9{H7R7>8LAFxFx*!WM06EP=W4+c;a9|Vig~-@zh}AlN z^1;$qcN+UQLcA<0b)g`VGb5ju5CmJ=M9adKR+5pev|5x!PqDQjtjU{#T#WK2xk}1& zz==&|O=9s@mI`pcT9sT22X4s7i*juX?t~a#7X`!}{8lQ$_b?|CBN7igf2|-C) RV3Gs z8WiCYE*%8%HZsa14G~%Krcs-?Rfh{}aMrwB+hi%AP_8K=IX>=C#akz`*{IIFpKCPU zC`L&z2!Y8`+&l=@&`bvgWa(j)qt0B_h>h2(2*uM^wS J+o9PE-LZjuvRG Cv z6=q*!_j^fN!%sC~o!mSM;_*8VY|P@2r{6NZ$Q zgK33*|-;#%kol!{mvBrySmn zJDS~eEbI@2;4mU0;n-otE! ~Ubj99tMx&Wv)cN2y@sQa6O2e54!yo4#Vn3LB zXYl`7a%N^GIh{=Ml1fg2lC$yuXP@^cADd4m #r&ZMSN@zlg_Ij2*z aDeNwl#x~OUOr_X7pG(dqXQLU%BR&ssz~ch| literal 0 HcmV?d00001 diff --git a/trydjango/lib/python3.8/site-packages/django/conf/app_template/__init__.py-tpl b/trydjango/lib/python3.8/site-packages/django/conf/app_template/__init__.py-tpl new file mode 100644 index 0000000000..e69de29bb2 diff --git a/trydjango/lib/python3.8/site-packages/django/conf/app_template/admin.py-tpl b/trydjango/lib/python3.8/site-packages/django/conf/app_template/admin.py-tpl new file mode 100644 index 0000000000..8c38f3f3da --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/conf/app_template/admin.py-tpl @@ -0,0 +1,3 @@ +from django.contrib import admin + +# Register your models here. diff --git a/trydjango/lib/python3.8/site-packages/django/conf/app_template/apps.py-tpl b/trydjango/lib/python3.8/site-packages/django/conf/app_template/apps.py-tpl new file mode 100644 index 0000000000..9b2ce5289c --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/conf/app_template/apps.py-tpl @@ -0,0 +1,5 @@ +from django.apps import AppConfig + + +class {{ camel_case_app_name }}Config(AppConfig): + name = '{{ app_name }}' diff --git a/trydjango/lib/python3.8/site-packages/django/conf/app_template/migrations/__init__.py-tpl b/trydjango/lib/python3.8/site-packages/django/conf/app_template/migrations/__init__.py-tpl new file mode 100644 index 0000000000..e69de29bb2 diff --git a/trydjango/lib/python3.8/site-packages/django/conf/app_template/models.py-tpl b/trydjango/lib/python3.8/site-packages/django/conf/app_template/models.py-tpl new file mode 100644 index 0000000000..71a8362390 --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/conf/app_template/models.py-tpl @@ -0,0 +1,3 @@ +from django.db import models + +# Create your models here. diff --git a/trydjango/lib/python3.8/site-packages/django/conf/app_template/tests.py-tpl b/trydjango/lib/python3.8/site-packages/django/conf/app_template/tests.py-tpl new file mode 100644 index 0000000000..7ce503c2dd --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/conf/app_template/tests.py-tpl @@ -0,0 +1,3 @@ +from django.test import TestCase + +# Create your tests here. diff --git a/trydjango/lib/python3.8/site-packages/django/conf/app_template/views.py-tpl b/trydjango/lib/python3.8/site-packages/django/conf/app_template/views.py-tpl new file mode 100644 index 0000000000..91ea44a218 --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/conf/app_template/views.py-tpl @@ -0,0 +1,3 @@ +from django.shortcuts import render + +# Create your views here. diff --git a/trydjango/lib/python3.8/site-packages/django/conf/global_settings.py b/trydjango/lib/python3.8/site-packages/django/conf/global_settings.py new file mode 100644 index 0000000000..f72b65415e --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/conf/global_settings.py @@ -0,0 +1,635 @@ +""" +Default Django settings. Override these with settings in the module pointed to +by the DJANGO_SETTINGS_MODULE environment variable. +""" + + +# This is defined here as a do-nothing function because we can't import +# django.utils.translation -- that module depends on the settings. +def gettext_noop(s): + return s + + +#################### +# CORE # +#################### + +DEBUG = False + +# Whether the framework should propagate raw exceptions rather than catching +# them. This is useful under some testing situations and should never be used +# on a live site. +DEBUG_PROPAGATE_EXCEPTIONS = False + +# People who get code error notifications. +# In the format [('Full Name', 'email@example.com'), ('Full Name', 'anotheremail@example.com')] +ADMINS = [] + +# List of IP addresses, as strings, that: +# * See debug comments, when DEBUG is true +# * Receive x-headers +INTERNAL_IPS = [] + +# Hosts/domain names that are valid for this site. +# "*" matches anything, ".example.com" matches example.com and all subdomains +ALLOWED_HOSTS = [] + +# Local time zone for this installation. All choices can be found here: +# https://en.wikipedia.org/wiki/List_of_tz_zones_by_name (although not all +# systems may support all possibilities). When USE_TZ is True, this is +# interpreted as the default user time zone. +TIME_ZONE = 'America/Chicago' + +# If you set this to True, Django will use timezone-aware datetimes. +USE_TZ = False + +# Language code for this installation. All choices can be found here: +# http://www.i18nguy.com/unicode/language-identifiers.html +LANGUAGE_CODE = 'en-us' + +# Languages we provide translations for, out of the box. +LANGUAGES = [ + ('af', gettext_noop('Afrikaans')), + ('ar', gettext_noop('Arabic')), + ('ast', gettext_noop('Asturian')), + ('az', gettext_noop('Azerbaijani')), + ('bg', gettext_noop('Bulgarian')), + ('be', gettext_noop('Belarusian')), + ('bn', gettext_noop('Bengali')), + ('br', gettext_noop('Breton')), + ('bs', gettext_noop('Bosnian')), + ('ca', gettext_noop('Catalan')), + ('cs', gettext_noop('Czech')), + ('cy', gettext_noop('Welsh')), + ('da', gettext_noop('Danish')), + ('de', gettext_noop('German')), + ('dsb', gettext_noop('Lower Sorbian')), + ('el', gettext_noop('Greek')), + ('en', gettext_noop('English')), + ('en-au', gettext_noop('Australian English')), + ('en-gb', gettext_noop('British English')), + ('eo', gettext_noop('Esperanto')), + ('es', gettext_noop('Spanish')), + ('es-ar', gettext_noop('Argentinian Spanish')), + ('es-co', gettext_noop('Colombian Spanish')), + ('es-mx', gettext_noop('Mexican Spanish')), + ('es-ni', gettext_noop('Nicaraguan Spanish')), + ('es-ve', gettext_noop('Venezuelan Spanish')), + ('et', gettext_noop('Estonian')), + ('eu', gettext_noop('Basque')), + ('fa', gettext_noop('Persian')), + ('fi', gettext_noop('Finnish')), + ('fr', gettext_noop('French')), + ('fy', gettext_noop('Frisian')), + ('ga', gettext_noop('Irish')), + ('gd', gettext_noop('Scottish Gaelic')), + ('gl', gettext_noop('Galician')), + ('he', gettext_noop('Hebrew')), + ('hi', gettext_noop('Hindi')), + ('hr', gettext_noop('Croatian')), + ('hsb', gettext_noop('Upper Sorbian')), + ('hu', gettext_noop('Hungarian')), + ('ia', gettext_noop('Interlingua')), + ('id', gettext_noop('Indonesian')), + ('io', gettext_noop('Ido')), + ('is', gettext_noop('Icelandic')), + ('it', gettext_noop('Italian')), + ('ja', gettext_noop('Japanese')), + ('ka', gettext_noop('Georgian')), + ('kab', gettext_noop('Kabyle')), + ('kk', gettext_noop('Kazakh')), + ('km', gettext_noop('Khmer')), + ('kn', gettext_noop('Kannada')), + ('ko', gettext_noop('Korean')), + ('lb', gettext_noop('Luxembourgish')), + ('lt', gettext_noop('Lithuanian')), + ('lv', gettext_noop('Latvian')), + ('mk', gettext_noop('Macedonian')), + ('ml', gettext_noop('Malayalam')), + ('mn', gettext_noop('Mongolian')), + ('mr', gettext_noop('Marathi')), + ('my', gettext_noop('Burmese')), + ('nb', gettext_noop('Norwegian Bokmål')), + ('ne', gettext_noop('Nepali')), + ('nl', gettext_noop('Dutch')), + ('nn', gettext_noop('Norwegian Nynorsk')), + ('os', gettext_noop('Ossetic')), + ('pa', gettext_noop('Punjabi')), + ('pl', gettext_noop('Polish')), + ('pt', gettext_noop('Portuguese')), + ('pt-br', gettext_noop('Brazilian Portuguese')), + ('ro', gettext_noop('Romanian')), + ('ru', gettext_noop('Russian')), + ('sk', gettext_noop('Slovak')), + ('sl', gettext_noop('Slovenian')), + ('sq', gettext_noop('Albanian')), + ('sr', gettext_noop('Serbian')), + ('sr-latn', gettext_noop('Serbian Latin')), + ('sv', gettext_noop('Swedish')), + ('sw', gettext_noop('Swahili')), + ('ta', gettext_noop('Tamil')), + ('te', gettext_noop('Telugu')), + ('th', gettext_noop('Thai')), + ('tr', gettext_noop('Turkish')), + ('tt', gettext_noop('Tatar')), + ('udm', gettext_noop('Udmurt')), + ('uk', gettext_noop('Ukrainian')), + ('ur', gettext_noop('Urdu')), + ('vi', gettext_noop('Vietnamese')), + ('zh-hans', gettext_noop('Simplified Chinese')), + ('zh-hant', gettext_noop('Traditional Chinese')), +] + +# Languages using BiDi (right-to-left) layout +LANGUAGES_BIDI = ["he", "ar", "fa", "ur"] + +# If you set this to False, Django will make some optimizations so as not +# to load the internationalization machinery. +USE_I18N = True +LOCALE_PATHS = [] + +# Settings for language cookie +LANGUAGE_COOKIE_NAME = 'django_language' +LANGUAGE_COOKIE_AGE = None +LANGUAGE_COOKIE_DOMAIN = None +LANGUAGE_COOKIE_PATH = '/' + + +# If you set this to True, Django will format dates, numbers and calendars +# according to user current locale. +USE_L10N = False + +# Not-necessarily-technical managers of the site. They get broken link +# notifications and other various emails. +MANAGERS = ADMINS + +# Default content type and charset to use for all HttpResponse objects, if a +# MIME type isn't manually specified. These are used to construct the +# Content-Type header. +DEFAULT_CONTENT_TYPE = 'text/html' +DEFAULT_CHARSET = 'utf-8' + +# Encoding of files read from disk (template and initial SQL files). +FILE_CHARSET = 'utf-8' + +# Email address that error messages come from. +SERVER_EMAIL = 'root@localhost' + +# Database connection info. If left empty, will default to the dummy backend. +DATABASES = {} + +# Classes used to implement DB routing behavior. +DATABASE_ROUTERS = [] + +# The email backend to use. For possible shortcuts see django.core.mail. +# The default is to use the SMTP backend. +# Third-party backends can be specified by providing a Python path +# to a module that defines an EmailBackend class. +EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' + +# Host for sending email. +EMAIL_HOST = 'localhost' + +# Port for sending email. +EMAIL_PORT = 25 + +# Whether to send SMTP 'Date' header in the local time zone or in UTC. +EMAIL_USE_LOCALTIME = False + +# Optional SMTP authentication information for EMAIL_HOST. +EMAIL_HOST_USER = '' +EMAIL_HOST_PASSWORD = '' +EMAIL_USE_TLS = False +EMAIL_USE_SSL = False +EMAIL_SSL_CERTFILE = None +EMAIL_SSL_KEYFILE = None +EMAIL_TIMEOUT = None + +# List of strings representing installed apps. +INSTALLED_APPS = [] + +TEMPLATES = [] + +# Default form rendering class. +FORM_RENDERER = 'django.forms.renderers.DjangoTemplates' + +# Default email address to use for various automated correspondence from +# the site managers. +DEFAULT_FROM_EMAIL = 'webmaster@localhost' + +# Subject-line prefix for email messages send with django.core.mail.mail_admins +# or ...mail_managers. Make sure to include the trailing space. +EMAIL_SUBJECT_PREFIX = '[Django] ' + +# Whether to append trailing slashes to URLs. +APPEND_SLASH = True + +# Whether to prepend the "www." subdomain to URLs that don't have it. +PREPEND_WWW = False + +# Override the server-derived value of SCRIPT_NAME +FORCE_SCRIPT_NAME = None + +# List of compiled regular expression objects representing User-Agent strings +# that are not allowed to visit any page, systemwide. Use this for bad +# robots/crawlers. Here are a few examples: +# import re +# DISALLOWED_USER_AGENTS = [ +# re.compile(r'^NaverBot.*'), +# re.compile(r'^EmailSiphon.*'), +# re.compile(r'^SiteSucker.*'), +# re.compile(r'^sohu-search'), +# ] +DISALLOWED_USER_AGENTS = [] + +ABSOLUTE_URL_OVERRIDES = {} + +# List of compiled regular expression objects representing URLs that need not +# be reported by BrokenLinkEmailsMiddleware. Here are a few examples: +# import re +# IGNORABLE_404_URLS = [ +# re.compile(r'^/apple-touch-icon.*\.png$'), +# re.compile(r'^/favicon.ico$'), +# re.compile(r'^/robots.txt$'), +# re.compile(r'^/phpmyadmin/'), +# re.compile(r'\.(cgi|php|pl)$'), +# ] +IGNORABLE_404_URLS = [] + +# A secret key for this particular Django installation. Used in secret-key +# hashing algorithms. Set this in your settings, or Django will complain +# loudly. +SECRET_KEY = '' + +# Default file storage mechanism that holds media. +DEFAULT_FILE_STORAGE = 'django.core.files.storage.FileSystemStorage' + +# Absolute filesystem path to the directory that will hold user-uploaded files. +# Example: "/var/www/example.com/media/" +MEDIA_ROOT = '' + +# URL that handles the media served from MEDIA_ROOT. +# Examples: "http://example.com/media/", "http://media.example.com/" +MEDIA_URL = '' + +# Absolute path to the directory static files should be collected to. +# Example: "/var/www/example.com/static/" +STATIC_ROOT = None + +# URL that handles the static files served from STATIC_ROOT. +# Example: "http://example.com/static/", "http://static.example.com/" +STATIC_URL = None + +# List of upload handler classes to be applied in order. +FILE_UPLOAD_HANDLERS = [ + 'django.core.files.uploadhandler.MemoryFileUploadHandler', + 'django.core.files.uploadhandler.TemporaryFileUploadHandler', +] + +# Maximum size, in bytes, of a request before it will be streamed to the +# file system instead of into memory. +FILE_UPLOAD_MAX_MEMORY_SIZE = 2621440 # i.e. 2.5 MB + +# Maximum size in bytes of request data (excluding file uploads) that will be +# read before a SuspiciousOperation (RequestDataTooBig) is raised. +DATA_UPLOAD_MAX_MEMORY_SIZE = 2621440 # i.e. 2.5 MB + +# Maximum number of GET/POST parameters that will be read before a +# SuspiciousOperation (TooManyFieldsSent) is raised. +DATA_UPLOAD_MAX_NUMBER_FIELDS = 1000 + +# Directory in which upload streamed files will be temporarily saved. A value of +# `None` will make Django use the operating system's default temporary directory +# (i.e. "/tmp" on *nix systems). +FILE_UPLOAD_TEMP_DIR = None + +# The numeric mode to set newly-uploaded files to. The value should be a mode +# you'd pass directly to os.chmod; see https://docs.python.org/library/os.html#files-and-directories. +FILE_UPLOAD_PERMISSIONS = None + +# The numeric mode to assign to newly-created directories, when uploading files. +# The value should be a mode as you'd pass to os.chmod; +# see https://docs.python.org/library/os.html#files-and-directories. +FILE_UPLOAD_DIRECTORY_PERMISSIONS = None + +# Python module path where user will place custom format definition. +# The directory where this setting is pointing should contain subdirectories +# named as the locales, containing a formats.py file +# (i.e. "myproject.locale" for myproject/locale/en/formats.py etc. use) +FORMAT_MODULE_PATH = None + +# Default formatting for date objects. See all available format strings here: +# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date +DATE_FORMAT = 'N j, Y' + +# Default formatting for datetime objects. See all available format strings here: +# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date +DATETIME_FORMAT = 'N j, Y, P' + +# Default formatting for time objects. See all available format strings here: +# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date +TIME_FORMAT = 'P' + +# Default formatting for date objects when only the year and month are relevant. +# See all available format strings here: +# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date +YEAR_MONTH_FORMAT = 'F Y' + +# Default formatting for date objects when only the month and day are relevant. +# See all available format strings here: +# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date +MONTH_DAY_FORMAT = 'F j' + +# Default short formatting for date objects. See all available format strings here: +# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date +SHORT_DATE_FORMAT = 'm/d/Y' + +# Default short formatting for datetime objects. +# See all available format strings here: +# https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date +SHORT_DATETIME_FORMAT = 'm/d/Y P' + +# Default formats to be used when parsing dates from input boxes, in order +# See all available format string here: +# https://docs.python.org/library/datetime.html#strftime-behavior +# * Note that these format strings are different from the ones to display dates +DATE_INPUT_FORMATS = [ + '%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', # '2006-10-25', '10/25/2006', '10/25/06' + '%b %d %Y', '%b %d, %Y', # 'Oct 25 2006', 'Oct 25, 2006' + '%d %b %Y', '%d %b, %Y', # '25 Oct 2006', '25 Oct, 2006' + '%B %d %Y', '%B %d, %Y', # 'October 25 2006', 'October 25, 2006' + '%d %B %Y', '%d %B, %Y', # '25 October 2006', '25 October, 2006' +] + +# Default formats to be used when parsing times from input boxes, in order +# See all available format string here: +# https://docs.python.org/library/datetime.html#strftime-behavior +# * Note that these format strings are different from the ones to display dates +TIME_INPUT_FORMATS = [ + '%H:%M:%S', # '14:30:59' + '%H:%M:%S.%f', # '14:30:59.000200' + '%H:%M', # '14:30' +] + +# Default formats to be used when parsing dates and times from input boxes, +# in order +# See all available format string here: +# https://docs.python.org/library/datetime.html#strftime-behavior +# * Note that these format strings are different from the ones to display dates +DATETIME_INPUT_FORMATS = [ + '%Y-%m-%d %H:%M:%S', # '2006-10-25 14:30:59' + '%Y-%m-%d %H:%M:%S.%f', # '2006-10-25 14:30:59.000200' + '%Y-%m-%d %H:%M', # '2006-10-25 14:30' + '%Y-%m-%d', # '2006-10-25' + '%m/%d/%Y %H:%M:%S', # '10/25/2006 14:30:59' + '%m/%d/%Y %H:%M:%S.%f', # '10/25/2006 14:30:59.000200' + '%m/%d/%Y %H:%M', # '10/25/2006 14:30' + '%m/%d/%Y', # '10/25/2006' + '%m/%d/%y %H:%M:%S', # '10/25/06 14:30:59' + '%m/%d/%y %H:%M:%S.%f', # '10/25/06 14:30:59.000200' + '%m/%d/%y %H:%M', # '10/25/06 14:30' + '%m/%d/%y', # '10/25/06' +] + +# First day of week, to be used on calendars +# 0 means Sunday, 1 means Monday... +FIRST_DAY_OF_WEEK = 0 + +# Decimal separator symbol +DECIMAL_SEPARATOR = '.' + +# Boolean that sets whether to add thousand separator when formatting numbers +USE_THOUSAND_SEPARATOR = False + +# Number of digits that will be together, when splitting them by +# THOUSAND_SEPARATOR. 0 means no grouping, 3 means splitting by thousands... +NUMBER_GROUPING = 0 + +# Thousand separator symbol +THOUSAND_SEPARATOR = ',' + +# The tablespaces to use for each model when not specified otherwise. +DEFAULT_TABLESPACE = '' +DEFAULT_INDEX_TABLESPACE = '' + +# Default X-Frame-Options header value +X_FRAME_OPTIONS = 'SAMEORIGIN' + +USE_X_FORWARDED_HOST = False +USE_X_FORWARDED_PORT = False + +# The Python dotted path to the WSGI application that Django's internal server +# (runserver) will use. If `None`, the return value of +# 'django.core.wsgi.get_wsgi_application' is used, thus preserving the same +# behavior as previous versions of Django. Otherwise this should point to an +# actual WSGI application object. +WSGI_APPLICATION = None + +# If your Django app is behind a proxy that sets a header to specify secure +# connections, AND that proxy ensures that user-submitted headers with the +# same name are ignored (so that people can't spoof it), set this value to +# a tuple of (header_name, header_value). For any requests that come in with +# that header/value, request.is_secure() will return True. +# WARNING! Only set this if you fully understand what you're doing. Otherwise, +# you may be opening yourself up to a security risk. +SECURE_PROXY_SSL_HEADER = None + +############## +# MIDDLEWARE # +############## + +# List of middleware to use. Order is important; in the request phase, these +# middleware will be applied in the order given, and in the response +# phase the middleware will be applied in reverse order. +MIDDLEWARE = [] + +############ +# SESSIONS # +############ + +# Cache to store session data if using the cache session backend. +SESSION_CACHE_ALIAS = 'default' +# Cookie name. This can be whatever you want. +SESSION_COOKIE_NAME = 'sessionid' +# Age of cookie, in seconds (default: 2 weeks). +SESSION_COOKIE_AGE = 60 * 60 * 24 * 7 * 2 +# A string like "example.com", or None for standard domain cookie. +SESSION_COOKIE_DOMAIN = None +# Whether the session cookie should be secure (https:// only). +SESSION_COOKIE_SECURE = False +# The path of the session cookie. +SESSION_COOKIE_PATH = '/' +# Whether to use the non-RFC standard httpOnly flag (IE, FF3+, others) +SESSION_COOKIE_HTTPONLY = True +# Whether to set the flag restricting cookie leaks on cross-site requests. +# This can be 'Lax', 'Strict', or None to disable the flag. +SESSION_COOKIE_SAMESITE = 'Lax' +# Whether to save the session data on every request. +SESSION_SAVE_EVERY_REQUEST = False +# Whether a user's session cookie expires when the Web browser is closed. +SESSION_EXPIRE_AT_BROWSER_CLOSE = False +# The module to store session data +SESSION_ENGINE = 'django.contrib.sessions.backends.db' +# Directory to store session files if using the file session module. If None, +# the backend will use a sensible default. +SESSION_FILE_PATH = None +# class to serialize session data +SESSION_SERIALIZER = 'django.contrib.sessions.serializers.JSONSerializer' + +######### +# CACHE # +######### + +# The cache backends to use. +CACHES = { + 'default': { + 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', + } +} +CACHE_MIDDLEWARE_KEY_PREFIX = '' +CACHE_MIDDLEWARE_SECONDS = 600 +CACHE_MIDDLEWARE_ALIAS = 'default' + +################## +# AUTHENTICATION # +################## + +AUTH_USER_MODEL = 'auth.User' + +AUTHENTICATION_BACKENDS = ['django.contrib.auth.backends.ModelBackend'] + +LOGIN_URL = '/accounts/login/' + +LOGIN_REDIRECT_URL = '/accounts/profile/' + +LOGOUT_REDIRECT_URL = None + +# The number of days a password reset link is valid for +PASSWORD_RESET_TIMEOUT_DAYS = 3 + +# the first hasher in this list is the preferred algorithm. any +# password using different algorithms will be converted automatically +# upon login +PASSWORD_HASHERS = [ + 'django.contrib.auth.hashers.PBKDF2PasswordHasher', + 'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher', + 'django.contrib.auth.hashers.Argon2PasswordHasher', + 'django.contrib.auth.hashers.BCryptSHA256PasswordHasher', +] + +AUTH_PASSWORD_VALIDATORS = [] + +########### +# SIGNING # +########### + +SIGNING_BACKEND = 'django.core.signing.TimestampSigner' + +######## +# CSRF # +######## + +# Dotted path to callable to be used as view when a request is +# rejected by the CSRF middleware. +CSRF_FAILURE_VIEW = 'django.views.csrf.csrf_failure' + +# Settings for CSRF cookie. +CSRF_COOKIE_NAME = 'csrftoken' +CSRF_COOKIE_AGE = 60 * 60 * 24 * 7 * 52 +CSRF_COOKIE_DOMAIN = None +CSRF_COOKIE_PATH = '/' +CSRF_COOKIE_SECURE = False +CSRF_COOKIE_HTTPONLY = False +CSRF_COOKIE_SAMESITE = 'Lax' +CSRF_HEADER_NAME = 'HTTP_X_CSRFTOKEN' +CSRF_TRUSTED_ORIGINS = [] +CSRF_USE_SESSIONS = False + +############ +# MESSAGES # +############ + +# Class to use as messages backend +MESSAGE_STORAGE = 'django.contrib.messages.storage.fallback.FallbackStorage' + +# Default values of MESSAGE_LEVEL and MESSAGE_TAGS are defined within +# django.contrib.messages to avoid imports in this settings file. + +########### +# LOGGING # +########### + +# The callable to use to configure logging +LOGGING_CONFIG = 'logging.config.dictConfig' + +# Custom logging configuration. +LOGGING = {} + +# Default exception reporter filter class used in case none has been +# specifically assigned to the HttpRequest instance. +DEFAULT_EXCEPTION_REPORTER_FILTER = 'django.views.debug.SafeExceptionReporterFilter' + +########### +# TESTING # +########### + +# The name of the class to use to run the test suite +TEST_RUNNER = 'django.test.runner.DiscoverRunner' + +# Apps that don't need to be serialized at test database creation time +# (only apps with migrations are to start with) +TEST_NON_SERIALIZED_APPS = [] + +############ +# FIXTURES # +############ + +# The list of directories to search for fixtures +FIXTURE_DIRS = [] + +############### +# STATICFILES # +############### + +# A list of locations of additional static files +STATICFILES_DIRS = [] + +# The default file storage backend used during the build process +STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.StaticFilesStorage' + +# List of finder classes that know how to find static files in +# various locations. +STATICFILES_FINDERS = [ + 'django.contrib.staticfiles.finders.FileSystemFinder', + 'django.contrib.staticfiles.finders.AppDirectoriesFinder', + # 'django.contrib.staticfiles.finders.DefaultStorageFinder', +] + +############## +# MIGRATIONS # +############## + +# Migration module overrides for apps, by app label. +MIGRATION_MODULES = {} + +################# +# SYSTEM CHECKS # +################# + +# List of all issues generated by system checks that should be silenced. Light +# issues like warnings, infos or debugs will not generate a message. Silencing +# serious issues like errors and criticals does not result in hiding the +# message, but Django will not stop you from e.g. running server. +SILENCED_SYSTEM_CHECKS = [] + +####################### +# SECURITY MIDDLEWARE # +####################### +SECURE_BROWSER_XSS_FILTER = False +SECURE_CONTENT_TYPE_NOSNIFF = False +SECURE_HSTS_INCLUDE_SUBDOMAINS = False +SECURE_HSTS_PRELOAD = False +SECURE_HSTS_SECONDS = 0 +SECURE_REDIRECT_EXEMPT = [] +SECURE_SSL_HOST = None +SECURE_SSL_REDIRECT = False diff --git a/trydjango/lib/python3.8/site-packages/django/conf/locale/__init__.py b/trydjango/lib/python3.8/site-packages/django/conf/locale/__init__.py new file mode 100644 index 0000000000..330833d4ac --- /dev/null +++ b/trydjango/lib/python3.8/site-packages/django/conf/locale/__init__.py @@ -0,0 +1,569 @@ +""" +LANG_INFO is a dictionary structure to provide meta information about languages. + +About name_local: capitalize it as if your language name was appearing +inside a sentence in your language. +The 'fallback' key can be used to specify a special fallback logic which doesn't +follow the traditional 'fr-ca' -> 'fr' fallback logic. +""" + +LANG_INFO = { + 'af': { + 'bidi': False, + 'code': 'af', + 'name': 'Afrikaans', + 'name_local': 'Afrikaans', + }, + 'ar': { + 'bidi': True, + 'code': 'ar', + 'name': 'Arabic', + 'name_local': 'العربيّة', + }, + 'ast': { + 'bidi': False, + 'code': 'ast', + 'name': 'Asturian', + 'name_local': 'asturianu', + }, + 'az': { + 'bidi': True, + 'code': 'az', + 'name': 'Azerbaijani', + 'name_local': 'Azərbaycanca', + }, + 'be': { + 'bidi': False, + 'code': 'be', + 'name': 'Belarusian', + 'name_local': 'беларуская', + }, + 'bg': { + 'bidi': False, + 'code': 'bg', + 'name': 'Bulgarian', + 'name_local': 'български', + }, + 'bn': { + 'bidi': False, + 'code': 'bn', + 'name': 'Bengali', + 'name_local': 'বাংলা', + }, + 'br': { + 'bidi': False, + 'code': 'br', + 'name': 'Breton', + 'name_local': 'brezhoneg', + }, + 'bs': { + 'bidi': False, + 'code': 'bs', + 'name': 'Bosnian', + 'name_local': 'bosanski', + }, + 'ca': { + 'bidi': False, + 'code': 'ca', + 'name': 'Catalan', + 'name_local': 'català', + }, + 'cs': { + 'bidi': False, + 'code': 'cs', + 'name': 'Czech', + 'name_local': 'česky', + }, + 'cy': { + 'bidi': False, + 'code': 'cy', + 'name': 'Welsh', + 'name_local': 'Cymraeg', + }, + 'da': { + 'bidi': False, + 'code': 'da', + 'name': 'Danish', + 'name_local': 'dansk', + }, + 'de': { + 'bidi': False, + 'code': 'de', + 'name': 'German', + 'name_local': 'Deutsch', + }, + 'dsb': { + 'bidi': False, + 'code': 'dsb', + 'name': 'Lower Sorbian', + 'name_local': 'dolnoserbski', + }, + 'el': { + 'bidi': False, + 'code': 'el', + 'name': 'Greek', + 'name_local': 'Ελληνικά', + }, + 'en': { + 'bidi': False, + 'code': 'en', + 'name': 'English', + 'name_local': 'English', + }, + 'en-au': { + 'bidi': False, + 'code': 'en-au', + 'name': 'Australian English', + 'name_local': 'Australian English', + }, + 'en-gb': { + 'bidi': False, + 'code': 'en-gb', + 'name': 'British English', + 'name_local': 'British English', + }, + 'eo': { + 'bidi': False, + 'code': 'eo', + 'name': 'Esperanto', + 'name_local': 'Esperanto', + }, + 'es': { + 'bidi': False, + 'code': 'es', + 'name': 'Spanish', + 'name_local': 'español', + }, + 'es-ar': { + 'bidi': False, + 'code': 'es-ar', + 'name': 'Argentinian Spanish', + 'name_local': 'español de Argentina', + }, + 'es-co': { + 'bidi': False, + 'code': 'es-co', + 'name': 'Colombian Spanish', + 'name_local': 'español de Colombia', + }, + 'es-mx': { + 'bidi': False, + 'code': 'es-mx', + 'name': 'Mexican Spanish', + 'name_local': 'español de Mexico', + }, + 'es-ni': { + 'bidi': False, + 'code': 'es-ni', + 'name': 'Nicaraguan Spanish', + 'name_local': 'español de Nicaragua', + }, + 'es-ve': { + 'bidi': False, + 'code': 'es-ve', + 'name': 'Venezuelan Spanish', + 'name_local': 'español de Venezuela', + }, + 'et': { + 'bidi': False, + 'code': 'et', + 'name': 'Estonian', + 'name_local': 'eesti', + }, + 'eu': { + 'bidi': False, + 'code': 'eu', + 'name': 'Basque', + 'name_local': 'Basque', + }, + 'fa': { + 'bidi': True, + 'code': 'fa', + 'name': 'Persian', + 'name_local': 'فارسی', + }, + 'fi': { + 'bidi': False, + 'code': 'fi', + 'name': 'Finnish', + 'name_local': 'suomi', + }, + 'fr': { + 'bidi': False, + 'code': 'fr', + 'name': 'French', + 'name_local': 'français', + }, + 'fy': { + 'bidi': False, + 'code': 'fy', + 'name': 'Frisian', + 'name_local': 'frysk', + }, + 'ga': { + 'bidi': False, + 'code': 'ga', + 'name': 'Irish', + 'name_local': 'Gaeilge', + }, + 'gd': { + 'bidi': False, + 'code': 'gd', + 'name': 'Scottish Gaelic', + 'name_local': 'Gàidhlig', + }, + 'gl': { + 'bidi': False, + 'code': 'gl', + 'name': 'Galician', + 'name_local': 'galego', + }, + 'he': { + 'bidi': True, + 'code': 'he', + 'name': 'Hebrew', + 'name_local': 'עברית', + }, + 'hi': { + 'bidi': False, + 'code': 'hi', + 'name': 'Hindi', + 'name_local': 'Hindi', + }, + 'hr': { + 'bidi': False, + 'code': 'hr', + 'name': 'Croatian', + 'name_local': 'Hrvatski', + }, + 'hsb': { + 'bidi': False, + 'code': 'hsb', + 'name': 'Upper Sorbian', + 'name_local': 'hornjoserbsce', + }, + 'hu': { + 'bidi': False, + 'code': 'hu', + 'name': 'Hungarian', + 'name_local': 'Magyar', + }, + 'ia': { + 'bidi': False, + 'code': 'ia', + 'name': 'Interlingua', + 'name_local': 'Interlingua', + }, + 'io': { + 'bidi': False, + 'code': 'io', + 'name': 'Ido', + 'name_local': 'ido', + }, + 'id': { + 'bidi': False, + 'code': 'id', + 'name': 'Indonesian', + 'name_local': 'Bahasa Indonesia', + }, + 'is': { + 'bidi': False, + 'code': 'is', + 'name': 'Icelandic', + 'name_local': 'Íslenska', + }, + 'it': { + 'bidi': False, + 'code': 'it', + 'name': 'Italian', + 'name_local': 'italiano', + }, + 'ja': { + 'bidi': False, + 'code': 'ja', + 'name': 'Japanese', + 'name_local': '日本語', + }, + 'ka': { + 'bidi': False, + 'code': 'ka', + 'name': 'Georgian', + 'name_local': 'ქართული', + }, + 'kab': { + 'bidi': False, + 'code': 'kab', + 'name': 'Kabyle', + 'name_local': 'taqbaylit', + }, + 'kk': { + 'bidi': False, + 'code': 'kk', + 'name': 'Kazakh', + 'name_local': 'Қазақ', + }, + 'km': { + 'bidi': False, + 'code': 'km', + 'name': 'Khmer', + 'name_local': 'Khmer', + }, + 'kn': { + 'bidi': False, + 'code': 'kn', + 'name': 'Kannada', + 'name_local': 'Kannada', + }, + 'ko': { + 'bidi': False, + 'code': 'ko', + 'name': 'Korean', + 'name_local': '한국어', + }, + 'lb': { + 'bidi': False, + 'code': 'lb', + 'name': 'Luxembourgish', + 'name_local': 'Lëtzebuergesch', + }, + 'lt': { + 'bidi': False, + 'code': 'lt', + 'name': 'Lithuanian', + 'name_local': 'Lietuviškai', + }, + 'lv': { + 'bidi': False, + 'code': 'lv', + 'name': 'Latvian', + 'name_local': 'latviešu', + }, + 'mk': { + 'bidi': False, + 'code': 'mk', + 'name': 'Macedonian', + 'name_local': 'Македонски', + }, + 'ml': { + 'bidi': False, + 'code': 'ml', + 'name': 'Malayalam', + 'name_local': 'Malayalam', + }, + 'mn': { + 'bidi': False, + 'code': 'mn', + 'name': 'Mongolian', + 'name_local': 'Mongolian', + }, + 'mr': { + 'bidi': False, + 'code': 'mr', + 'name': 'Marathi', + 'name_local': 'मराठी', + }, + 'my': { + 'bidi': False, + 'code': 'my', + 'name': 'Burmese', + 'name_local': 'မြန်မာဘာသာ', + }, + 'nb': { + 'bidi': False, + 'code': 'nb', + 'name': 'Norwegian Bokmal', + 'name_local': 'norsk (bokmål)', + }, + 'ne': { + 'bidi': False, + 'code': 'ne', + 'name': 'Nepali', + 'name_local': 'नेपाली', + }, + 'nl': { + 'bidi': False, + 'code': 'nl', + 'name': 'Dutch', + 'name_local': 'Nederlands', + }, + 'nn': { + 'bidi': False, + 'code': 'nn', + 'name': 'Norwegian Nynorsk', + 'name_local': 'norsk (nynorsk)', + }, + 'no': { + 'bidi': False, + 'code': 'no', + 'name': 'Norwegian', + 'name_local': 'norsk', + }, + 'os': { + 'bidi': False, + 'code': 'os', + 'name': 'Ossetic', + 'name_local': 'Ирон', + }, + 'pa': { + 'bidi': False, + 'code': 'pa', + 'name': 'Punjabi', + 'name_local': 'Punjabi', + }, + 'pl': { + 'bidi': False, + 'code': 'pl', + 'name': 'Polish', + 'name_local': 'polski', + }, + 'pt': { + 'bidi': False, + 'code': 'pt', + 'name': 'Portuguese', + 'name_local': 'Português', + }, + 'pt-br': { + 'bidi': False, + 'code': 'pt-br', + 'name': 'Brazilian Portuguese', + 'name_local': 'Português Brasileiro', + }, + 'ro': { + 'bidi': False, + 'code': 'ro', + 'name': 'Romanian', + 'name_local': 'Română', + }, + 'ru': { + 'bidi': False, + 'code': 'ru', + 'name': 'Russian', + 'name_local': 'Русский', + }, + 'sk': { + 'bidi': False, + 'code': 'sk', + 'name': 'Slovak', + 'name_local': 'Slovensky', + }, + 'sl': { + 'bidi': False, + 'code': 'sl', + 'name': 'Slovenian', + 'name_local': 'Slovenščina', + }, + 'sq': { + 'bidi': False, + 'code': 'sq', + 'name': 'Albanian', + 'name_local': 'shqip', + }, + 'sr': { + 'bidi': False, + 'code': 'sr', + 'name': 'Serbian', + 'name_local': 'српски', + }, + 'sr-latn': { + 'bidi': False, + 'code': 'sr-latn', + 'name': 'Serbian Latin', + 'name_local': 'srpski (latinica)', + }, + 'sv': { + 'bidi': False, + 'code': 'sv', + 'name': 'Swedish', + 'name_local': 'svenska', + }, + 'sw': { + 'bidi': False, + 'code': 'sw', + 'name': 'Swahili', + 'name_local': 'Kiswahili', + }, + 'ta': { + 'bidi': False, + 'code': 'ta', + 'name': 'Tamil', + 'name_local': 'தமிழ்', + }, + 'te': { + 'bidi': False, + 'code': 'te', + 'name': 'Telugu', + 'name_local': 'తెలుగు', + }, + 'th': { + 'bidi': False, + 'code': 'th', + 'name': 'Thai', + 'name_local': 'ภาษาไทย', + }, + 'tr': { + 'bidi': False, + 'code': 'tr', + 'name': 'Turkish', + 'name_local': 'Türkçe', + }, + 'tt': { + 'bidi': False, + 'code': 'tt', + 'name': 'Tatar', + 'name_local': 'Татарча', + }, + 'udm': { + 'bidi': False, + 'code': 'udm', + 'name': 'Udmurt', + 'name_local': 'Удмурт', + }, + 'uk': { + 'bidi': False, + 'code': 'uk', + 'name': 'Ukrainian', + 'name_local': 'Українська', + }, + 'ur': { + 'bidi': True, + 'code': 'ur', + 'name': 'Urdu', + 'name_local': 'اردو', + }, + 'vi': { + 'bidi': False, + 'code': 'vi', + 'name': 'Vietnamese', + 'name_local': 'Tiếng Việt', + }, + 'zh-cn': { + 'fallback': ['zh-hans'], + }, + 'zh-hans': { + 'bidi': False, + 'code': 'zh-hans', + 'name': 'Simplified Chinese', + 'name_local': '简体中文', + }, + 'zh-hant': { + 'bidi': False, + 'code': 'zh-hant', + 'name': 'Traditional Chinese', + 'name_local': '繁體中文', + }, + 'zh-hk': { + 'fallback': ['zh-hant'], + }, + 'zh-mo': { + 'fallback': ['zh-hant'], + }, + 'zh-my': { + 'fallback': ['zh-hans'], + }, + 'zh-sg': { + 'fallback': ['zh-hans'], + }, + 'zh-tw': { + 'fallback': ['zh-hant'], + }, +} diff --git a/trydjango/lib/python3.8/site-packages/django/conf/locale/__pycache__/__init__.cpython-38.pyc b/trydjango/lib/python3.8/site-packages/django/conf/locale/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86526a4b8a728c1ba0dbe45fc51eab4e451df9f7 GIT binary patch literal 5790 zcmeHLd3;pW6`o8oSq3AU`}$k~Yl!=TiY6=}k_03H^|{15bMDN$%$xUy``$~K=@y6; zYo+c2N-axR#TXE4K)|+vwzif|tQ8o$Osd7D+P$`=w)UJiHwpS{|LlL}{^pzS-h0kn z&OPVcJDFQq84lo|G3mqD>lXzAZ&KyxKZcbX@Z&sO5(q#*4?qzFp%_ca$`S}cDU?CE z&x@b}!Z1R$9|M(etZE+#qhPe+V_+;Cr}*)30-UJ$NpLcpqWGzB8l0~98E__Oik}5% z!#Rqd3+KW4ijRZwFhTJP;B#=H;#DvasujNoE{01KzZ5RRLhCPr%i#(v1%4%5g{8o+ zhDlfo{2I6xu2Xz6Tn{%WUIVo-Me(UH4W=tz2Q#2v@f%?#G$`H(O)yLG*>DpU8b1Vc zpcz_J`&^g@H!FS%+zPtlx54djhvIiaE8L|xg9t fCsS@=6VPo#!}#qz@zY(;*Y~JSg!aAcmkeOd?kDXo>KgqunJZy zz6RD}DU8zv>#!8~de{IP72gD#;c3OUz%$UT__NRhTNU31&%t)ZpNDV33ySx`4%n&q zi?9oJE4~L_!cv&)+wdLuuHt>L7xpRsJ@`KSK=GI1hwvlCUx6RPe#L(RS?E{%Rro2q zrufg`bvU5-K{y0C#ovIR!!H#7CHxBViVwiA;Z4Qgg5SVl#ovZ^;9bSvgWtmYihlsV zgWoIu2lylWN%23!U*NBbe+YkrzxzA{|9~U#Pu2br{0si=^N$}af zAcw3NKPC7H4M`XK(xf-c3L^}UHPnkzr7Q2!Y0R?b!1(f_K!8n02shL;)wR|)O`oL+ zM`Id@s4HxX$+YIU(u=yD E=!AW&2u==x}6k{iddS4A;wH?P+T+ZxQJ@) zhKL#(*xa$kx#5^?ns&S9;<&D4AbeYxIESo?vT<6~WTN9fHO9p7^jwg|^op986bZ&G zXF`cy5)mMBB~crAu7tLyhlfqlg7Q)?t&uDuqTVRHC=PBoboap>2e%&Fc<8=E4;|c; zD`t+Xm)AIW0D@V11y+6Lp=w4SQIp{^!o+-L39l0MYcemdz=kw#Kgx2!2u@eaO(s1D zwY}p|BD*#FeD=j`Pk%>$XaAz?PGk?DU|g@L^~^Zh9OcINa{c$A+;hGp$@QX?rI*!m zD~@OAjYOIJ`YrkOd-CfS=htsTfdkTFG4-R~nH#W7rmtW3z*Lwqwx_$|JUerb&og zFv|3@DGWUVr!2$aqQv`FVTYrKret{3@Jg|H?^5n0(%72TLpO8NF;FX=l#E6Ork75| z%{xXe1T-u*alN#TqhI1;r*hAAqDHP5oJgj!!EWbLYqn*C7IF;Ore!;5KYuaY%!TSC z=L!ED_CL1&MJzAu-@Sjw{+;`` Jo~7Yd4&!Aa=wk5=&eZC~6H znK4Z$EEz`mu*RpCH6-FIweifDdEDX|4;}G;D-DUDZP4SVIp{>Vk6egz$3 v=lUw9*W5{IZ&MGp?YjXKdWP0m~osj4w;e7QQP&;6kAP ?5bKs!^8xO2Fuo=6A9-1L6Ob g7|Ujj5C(WQJ^GE;(hfL2f%2bK$VtRvNan<`?`niYqfby<&!kG3n=r(nc0fGnoqt zrjMw{gegr-q8_FKVe7^9fFJ;uB|s0?TY%w7ThENDWd?JYHq?X?j$Tn8r6a?;z~5`% zQpe;NVl upvq)o0@xNHF?GgG*zpP=RpOBlW( zUwtCmlYJrE^Xik>mDEEsjU>lyCooE9GRtCst4!FaVoQz_(pi1**vj{wf9Czix95Up zM6Yb{7V;$CQMe+<@Y7jC-_ve}M?8+9M_D6ix_Y=lxCS~qt@;=oq(N}kYZLocCm5ca z*`}8@Ft?3*X$q4#-?tjGb26ca8(Ea2jj7j9y(@9eJ2Cxk&+f_Y_LDCr)ugFcG-3`+ z<0pw#Or4Fk6}QQ_Se1HNBL >B8Jbf9CW&$kS8EFb7Vd &44*^NKOy={kfoxsd1L$a2NfKQe$>`e+L;X7feyyd)9osF0o?jrL)mW7^kHv z+w_xo3J+|yEnP3}kv%BlRJCujb0m~ gvo_Ox0beE zKF7ujg$|Ndgq6NE*4|F+^7OJfp5tetV`;6c=vFNpZFWa4=%Cj&n|2#Z=oR!$@q<^H zgJ)i-(vWm<7i#-f?_DY^bX{iwUi$c)p(!zq84E-T8_^e<@xCG*@ {{MLK&J=^kI7v+1FA)<(( zm$Vp6_;H`_U6t?Mmhas}xa018@3MUF8kE7!wRkc?!ALf4>Dwg}eH$>txh~D`;v>el z@EUxPEcRa|OR_z=Vh@sf>0C&9c {<-3U3dx|{fl!!5A8lTA(?-V7J_hXb|;#x zr+*oRVE_H}0zx^dm&}#m`BVFs$+L&<%>~ 0Qj@<>_6s50;ok{Q!1k||Tf1U^2e7{X77w6?dqJKoy;$XmV79DaPsptPGA+j7(s z^AqAb7QOrQqXqE^cS(Gv2PFO M_THADs*jD+8wv imrlH@+7T|VLg@tk zKC4zDQQL}D`#;Zkb!#g|iQC#bF_q4hUz@bSGx=n4I%ivPAW$+QSmc+FO3FTCpV=Vz hnI9DWpKTB*{Ww?>EGnVmTYHEVdj30h1PbM~{{X{=EK2|Y literal 0 HcmV?d00001 diff --git a/trydjango/lib/python3.8/site-packages/django/conf/locale/af/LC_MESSAGES/django.mo b/trydjango/lib/python3.8/site-packages/django/conf/locale/af/LC_MESSAGES/django.mo new file mode 100644 index 0000000000000000000000000000000000000000..8d85caeb10aeb93fb9a8e0119d50ff1b68e7d7e6 GIT binary patch literal 19601 zcmb`O3!EKQea8m~2mu8n2vor#5O)`LHwntajS-S;HqTAA$tJvnIJ `k>ecpi(P}Rx7QK7OU;|ch0%5&D}iE`{AGO z%$f5(|8vg&od5EzMGJ29_?>=)=RF<%+p(VaLY{AbvO+!Y=2Q6w-w12)!*D%3=QPi| z7*^qP;5(txe+NDZ{u-VHPayHh@C>*Jo(~ni)^R61n)jk()iHCNb$kijLcEv5ZSWsp z0DFGV^R9ref>rokI0k?JX`Xi;d^=nW{~j)ZkHQP!sZ@3;9EE4W7sDgrTj6o=?T~Kp zZifrt``z~syYF{Ey2|@3RQ Pl4Zb?>~fU_oMK5xZn&M? )5G9=!&pz8fgsB|h! z-xor~KM87lPK9bmFI4>JLXGQMsCeVB2VMo0{(AUC_$sLW{d1`Ld lb;HgLVX{B8iy<4DKLT0gfEBcuiK&e;||BqK)TZV zB3u9;hKlzisP_LHDxY7w@TV;Cyg}a2fa=H1@F=+5y zhX3N;zvJG&4^{q;q4evQ@C0}yjZpZB@Mw5CRJ)%674Jf*a#um==?18N-vKp`UJsS- zPN;bM9Pfdu-@R}Fe8BM`_x)jb4B %xBpRqj!J^ff#ND*j410@uQ2@Q+~v z?}X>V0sdJHFNdq(E$|ZfAXIzLU~m?~bD-+K6lz>Ah06ajsD9c7kA;Z~-viZ;*SYW; z;9A~a1J}WO;c@V3bdvH}0yRDZQ2nt2s{Acb@peGXzg -$RZ#Qe^-%r!0jP3+ z1eN|jpyK_)@i*{z-j5lu{kO>RG^qGzLh0EO$8(|P@lvSrH$%1nuLLy?*F&xEw?LJ9 zCsaS&1(na;Q1kw)?)!J4>hpca|8U{Igew16Q0+Yu g=9s8itJqJDsZiFiD3aI#1sCDx?sCM4y_(sRK zIKIvC9ggpDe4pco96#dtaj5aS6RLkc@51kK{3_JEy4QXGrVGCxo 1c78n{YTtP)l)gRyp9mjwJoeePy-$T|@3~O@v(j-CYCNxYoOFyF z6URD~zPu1#4)23SILM}X4ZI2F@aItRcC%P8B;MyBP4IpOnfl(6i|jr-2KD_F@Emvt zq`BVxQ2q9xdw&?J|9$|~Uq6P@!=FOMdkm`nM_p|7`Zy^4crw)Yv!UAE57n=iK l?foH;R!&BgI;7)il zi@VmVGSoWq8mM@G1Ah hwp)E&pxPr`UTYZ zX;abru~6kKg6hBJF8m^>{#^ytZzE9Yc0lRl)lmKOS}47`(Y@acmCsw@6nqC%|DV8S zCY}QI{Y M8y&YeZgbq}cqLT6*Ffo0$%QA58B}>Qj(efn{bDG6eHlCg){z~^cMz@b ze}J6Ghku7L@-pOB)a^wxjTamMn z>k+L>-$(S@jl9S_S-a`k?pa_-@xF?@UN8JKo 3zP zCCIQ|_&v+Q*sSi+;Q9PJiF^*3Ku{C&+r_^RA(tYfNaOeU#sfSR`6=>A R{wux%ax%u)CZ z@&IzbUfO<|D*^H; ioqBKj>rD#-EV|7Ca#d qP{|RaT zy@r>MAm<|YA~i(66Oh}GMWlPP0{GpG+=%=@FZ{lRd=$x$Cn47$|A@R7IgNBj!w@-& z=Rr7*Jc>L4dACUT|H1De3wVAdyb^gAvJv?b@+ZhLr1AS-9$ta`1erm;fV>A;ja-Q6 z_m>vlFW?aJ=SZIm`>f+1!4D$~DffNw7UV66erH-V|6R({Q;2t$i0pA+UI(9syb3wd zg k|gDNZC5^9qeNv?O$uRUR~(qS&qR62&r4B8^3Ie&B@KhZ ztZnciC(NkZ{wcF)Z`fDxCuZ}I3begt-jae}2xcA3YbmLxdKXPVHHzy>Sn%zW4NT&^ zWWw}df@Z?7tPs%z%!Yx4*-78>uz28%LMCmP`de5; z`u*{g`Oowp2`X9Fo^IsrQq76qyFMxu!q_*HpGCl~3w=C=X_};cnb+@o%bGK9$Q!z3 z@GNiDsJCh=jmkj~XWpvHL=Z %81{2XFD6-l``rvP`5g{vitLjB&4aoA8 zNyV47aj{~)>$og|fz zta{hlZs}-XU)Rt5wzt%6>O@7#Obb@0!QRMJY%EE0Y8z%$gylS;5^0oE)n=7f*DJ*! zHPx%9RYhDA KoL;*?Yoj5&5s)y`r0Rr)lcDrZ4{d75YlS_?8;&$>lXRA13*nxSshNgm z9}6m#WQOXXNNCM)J*VKc)gY?)L7|X_S;ku}pY<7?ocUbvSs*7XL6*6lW6)% 15ofMOX%h#hKt`z zpJ?C1Y+%Y^`V{)w>Tt;UWCzcvZI8`;CW@&}C8|dGF1rtRuU1w{W*QOZRPAtbY_H&< zX6d@@cUQ*)XLwjuWMmk!w%)U;O>kTLvaVf5tRl9a#-HgLYgG)dt+S=&$=qB!mBIEn z$t$cEhm=-j1XvT*nwBSPXemz{Zq}M)$_AV1Y{MH{Ya<@zVvzM@m3py<%;JnSDvFCf zNy(NpS-;zkd8o7Sr5Oeciytj3&DKg`+?Kh`Y{S^}vl}a4t3qwxNJ^Xw4-jYGZ#%Ya zo|~nNm2P3qfaz>#*uE^!P1Q6PI@4G~s58tAS1bKYiG8zaw%DjiT$%L?S{gIIwPj7r zYRIaAdM&GkX%OcLPi%_XzDB}{v>v3h-iS^p8U&p+hEN@Qps*(ozE(o>kFPToPq8rx zMr0Cc@M>CjU3I*XB%LsJiJro!82g*TS-)3Vu~0L@oCMgss91`Xpl#KZ)#r_H#9}8K zNh66)7QomLBlTPx5@tS@Mv{eQAKO){)UibR?Ab1uX8#K&=#`0ZGN@ 20V6m=PPabE{i9;5D{$%rb&8T};z9Sd)SvdZt2W)&ric@=DWu%q?{>Tex0%(ntx>$+t3z;+?lSgmU)HCQ#oWmVR5j?{lDC1)O6}el#6}f123UMD zi8j_TYc|&7(AyNmaZm{0-k@CaHkGPaEt?o!l5Gz1X(iu`1y{%V(PMoNh7Cu+qVgZb zGN8HoFp7yai&S}vX9x0RfSz`G5V01Nq8eXPlwg$6ALYD0*=B)`V#py<3{Xr=tw&`8 zM6vAv@-Ro3rY;x@Y f!dV9Q~QZXx3|ps!o@?UuybqBXN!#n7#(ghhyh zJ~ozyLDmKaE;DAo$Sr+r>Y^f1U7v|J8KLC`1!z0>XV|E-`UG1h6M$-U4ffZR!pX8J zlbMkeOa(NJXr?NnMw_%%oufNT(LuU1L?`KvkaQ-L!uwlh<0Q?>RASoNqgydMWtVP^ zLyZxtYNu*rh_ GB>HaaLW8p0U)l($le;>}*U5 zm7O-m;x4rqlMT^2s2Yo|USnQL|IzwDEoErzI>Ej$Q;H@_%~QO+M G;dwH zlx^y#YB#QIP#kQz_FEm@-yE=lW`&m}if!MF>dt*uQ`mit?x g-WHK(eJO}EUG%eYQMHp@fJrosf6apc 3q!-m#a_N+FuY?y=SARl=)b6g9DQDk;=_S5n_ z-{N|u((#G(DdsObEo-XDju2(kP>D`6aJ)p_O59YcP2-%&z40_CprA>N1>G2waqcq^ z8>ya_)nLp*Z%3h8PjhcaIStHBiMJyz$H`3W?WkcF6`Eyov@fECYPy-evq{}&bt4L^ zq4ohc$xS_385Lb~Rkn7T)=?rZ9!wtIj O3j6HXA_;)dppB8+*_A9(!9di z8HKqHl4#mx>_rG#r?y`fR%p}}Vde#c>?pwmM$hyh2Tit>1@>lWPFTG-HyW21bAzxh z=LTV9>=z_6qceMBbaVz;vtVx6+=OglbF*hNn;Wz}tSPL*WpGCm+XC!mS6h_kWldXH z(|T?TYgke3L8gJN%x&vh@2+X>0ko_2+T54h!Wvt2Taa31*BdNQFQ}znP%nC1(0Ehf zgtwdZXLr4V#9o!DiR;3vMuj*kmU1snn7DB=?In}Bm!w`zTEH2?n+>!6IO!+yMCgsB z$!^xyfenR$o!YsRc*rl1Z!uZ8Ev#|pHZYnMqr$-IdNCUqPlo)3V_U}u*64Uj+<{?s z^CAEIWy>!bSiXE<`33&+3x}3paNe@z%a##wU|TqivA=)33;kuwhn7F ;3X=$l#RRc^RlflwpYH8oX(G8<(TkT&yxNPAXrb!r6FLQL# zg1MCIuqa-^c7gLE%vbIh9~ro~6;EYNh3UXrXVeY(7f(cav!X+OFtu>Z9Bu|iv{euJ zu|4Z#E6-oy+sBo?v47S|e|g`Eh3&qs2~G%H?D}yeZ;eh2=B_dG%h-$r$}Gue3z@dS zZf-4KR$5Xi`!h*eP=Xa4Ddp%Y`i1%g#!05LUr~M<>@YS_<=Ix~Af=imyyfjm!kmMA zggL52{&XZ$PBlABcUP5sN>P{=C~ d9lI*d-)uX*}PfE_0?!aTVm(! z;)aE}&~$$BS~D)KLQs^?st}mBx^;bVP;I!o>Np!4jxY1X$P}6nCYsE2h0KIy^S(P^ zZt}jHyI%RY4$ kIov zBh={zaXDk2yKJ=IGzxH8YJ|zNi({#o=(ozat)gAZXt}`-)Btsj8l8qk4i$~Iba#f) zTXtI|KHb^qOy-T$y=(t8vM (T@>7XO)9i~5-9uHUSW z3 SHkr#u)FCTtQ*Kq98^uk=i$+o7%4a;= z9TtnK&~V5tuUuyJs?T+mow!T_<3>{$+n1WF`D}yf(yH~Owd*T3a5^)q3ayI@I*}Ln z;{xtp+}37x6HZo~IH^DPmzvvKLgKUI7jU8t)DoO-@~C;6!+p2;m067S*zZAI4(Lu( z_v^0K46*GCmUrq)Aq5Q)C9x0_g7x3>q`9isDr}W31g1KVD|Ojk#;7@mnm(JwAn~UY z&K>I2=Das^`EV;^GGnLz9p+~27TjtqLXWdHGJNLEpkY^3_PsYu;~=P-tu(2b&S0ci zEZjg9{4zI(EF3u8v|?-F@9?;__4wn-73a^PX4|&uV}HucZ>!nvOX^ 5xCg_?dpyKeLorCbTC zIopR?P)=&Kkb9oCx;C 2{oW8?Vpu{Zha0Mt^ISCa=7l9uVwT *8suI_v&OU3ecUB3DI3=_ZnA>X&Rw1mX41oNH zZVPAmo#RO~HiWwh;ncZP_LLN*n |K2V#h2k%Y7XKQqeR>ELPkY}~dY z^(;r_3Aamg#I0(Eb=~ltFHyU_=@sirq`ampaTxXHl}hkOjmDK2Vh75Zn1tSXPEizt z8&1wd85z!%sK+aqFtS0$^k=6y^<=r2UghZA#gRyg^-YVg-Icht^C;Neo2VVXaUwEy zv#jb)w_+ No7G^?gj z2XiZ;VaQO`JSldI+|t#yYN+>2#?)Lhw8nvLD$1z24K@aibeqe4R(EP(%u17_`!~OR zbD>6M{^Zzrpv~lS8|pMy3d)t!^q?)Ms^05X19Yj}EnGJpbHcY^FcQ5;zwPgnq+4X+ zuMJ}}ymY2Ump?R?Thx z6MJdn&V zdRl$2^DTd?qSMH*6p+6|3@4cT{85DYixX$ANTsY*@!Q1Gz#J^6&NyTI2`cNX`IAx2 zU+a;?PukLewlEA6`md=QEk`9z9UPVW-pgMj(6<4e%8+vdOP@Q* fpw_rwo(8oe}5BY?ukAR3_?SWY_W|;IEv~{^=;c zB^Mjoo~hNeW?qqz-M$;=rDEZ@MgyE1)3n{XFIkQC*FNT;+vdOAG^Z=wbxFg4sZ?{5 z%;T6$yzTn4kYc-ElIveQthgo1TyEgNYkDQMN#K{{)XyF~u8rAvCQ-W98rfVKE38I? zY}oeJ*<2MhRt hC