ELF>@@8@XkXkppp11pppDDGGGx(G(G(GPtd###QtdRtdGGG;6Psjn?iTe~$1 3a bf}A+ ^Bt \cO q#Rh':oZN%<;k8LFupg7QK!-,S*zE/(Gvdx2@& 9U>MVry]4`JW  X5 |I ).m{"Dlw=Y[CH0_ ¨'  @U䔉DJDh0C0    a@HF& H4$($0D P)D.$3`ST    m\šy_cKtk DZ\A {񫮦^:<. ӰU"\x;KLI1#eY|g,1[^ZmV!`mcbBD̙x夻h h2c/]nX9Z[0S+-JO8Є=,$pcxK%(O Q>E*pJG)7H+wd! ũwi2۝CkE7 -CMa|R#=JYϟ{4KoG#3*im =zj7nqřU [u 5-0j [ow'M7nq o|rz`팡/qL}K ʬa!D]38B3$AnE%iaD#[hʑBjȤAzf ) ba:å;{[&?e&"Gif뎥 RMoi    lR  |xV}   +:  L" IO_ t  aK  &  i' o  ~ 2^  i   ;\  v (%d5$ }  % %6E  &L ME d < :   ,   h  o 9 "   +2 v   0L  J Z(^M 6op p{h_ b{; 5&  # }\ Z0^E  d   XsO  А U w @u_ `   $  Y7 X Eu |' s/Z  |  c  }o^  n yA D  n0 @^ @Xh  V  c$JX^i 0d_YB    @a c x `e :  `n |z y  uPO PA (fVh^ {L P=  `^o  4 0^&6  " P x^Q@ Pe | t @  6 Љ   W   Y7[ p0  `]P^] a#UB ^ @3E {v @  pq^l @s9#H^ d. C u @}V  g   p]" _ ^ v%Tu > u  _F `a[ p ^4 9~  ИA  pe 8^  {x ~ ?  PY$ [ 3 d|Z  P4@   `zf } pc$  ce`^p^1   P S K  l Mw 67 `|h__gmon_start___fini_ITM_deregisterTMCloneTable_ITM_registerTMCloneTable__cxa_finalizeshare_setopt_docshare_close_docshare_docpycurl_version_info_docpycurl_module_docpycurl_global_init_docpycurl_global_cleanup_docmulti_timeout_docmulti_socket_all_docmulti_socket_action_docmulti_setopt_docmulti_select_docmulti_remove_handle_docmulti_perform_docmulti_info_read_docmulti_fdset_docmulti_close_docmulti_assign_docmulti_add_handle_docmulti_doccurl_unsetopt_doccurl_setopt_string_doccurl_setopt_doccurl_set_ca_certs_doccurl_reset_doccurl_perform_rs_doccurl_perform_rb_doccurl_perform_doccurl_pause_doccurl_getinfo_raw_doccurl_getinfo_doccurl_errstr_raw_doccurl_errstr_doccurl_duphandle_doccurl_close_doccurl_docdo_curl_traversedo_curlslist_dealloccurl_slist_free_allPyExc_TypeErrorPyErr_SetStringcurl_easy_setoptg_pycurl_useragent__assert_faildo_curl_getattroPyObject_GenericGetAttrPyExc_AttributeErrorPyErr_ExceptionMatchesPyErr_Clearcurlobject_constantscurlobject_methodsmy_getattrodo_curlhttppost_dealloccurl_formfree_Py_Deallocdo_curl_newp_Curl_Typecurl_easy_initErrorObjectempty_keywords_PyArg_ParseTupleAndKeywords_SizeTdo_curl_duphandlecurl_easy_duphandlePyDict_Copyutil_curlslist_updatep_CurlSlist_Type_PyObject_Newutil_curlhttppost_updatep_CurlHttppost_Typeassert_curl_statePyObject_IsInstancepycurl_get_thread_statedo_curl_setattromy_setattrocheck_curl_statePyErr_Formatutil_curl_xdecrefPyThreadState_GetPyEval_SaveThreadcurl_multi_remove_handlePyEval_RestoreThreadcurl_easy_cleanupPyObject_ClearWeakRefsdo_curl_deallocPyObject_GC_UnTrack_PyTrash_cond_PyTrash_end_PyTrash_begin_Py_NoneStructdo_curl_clearcurl_easy_resetPyType_GenericAllocPyObject_GC_Deldo_curl_errstrdo_curl_errstr_rawdo_curl_getinfodo_curl_getinfo_rawdo_curl_pausedo_curl_performdo_curl_perform_rbdo_curl_perform_rsdo_curl_setoptdo_curl_setopt_stringdo_curl_unsetoptdo_curl_set_ca_certs_Py_BuildValue_SizeTkhkey_typePyObject_Callpycurl_acquire_threadPyErr_Printpycurl_release_threadPyLong_AsLong__stack_chk_failwrite_callbackheader_callbackopensocket_callbackPyMem_Mallocinet_ntopPyMem_Freecurl_sockaddr_typePyObject_HasAttrString_PyObject_CallMethod_SizeTdupPyErr_NoMemoryPyErr_SetFromErrnosockopt_cbPyObject_ReprPyText_AsString_NoNULstderr__fprintf_chkclosesocket_callbackssh_key_cbseek_callbackread_callbackPyBytes_AsStringAndSizememcpyPyUnicode_AsEncodedStringprogress_callbackPyObject_IsTruexferinfo_callbackdebug_callbackioctl_callbackssl_ctx_callbackBIO_new_mem_bufSSL_CTX_get_cert_storePEM_read_bio_X509X509_STORE_add_certX509_freeERR_peek_last_errorERR_clear_errorERR_reason_error_stringBIO_freePyExc_OverflowErrorPyExc_MemoryErrorPyExc_ValueErrorPyList_NewPyTuple_NewPyList_SetItemstrchrPyUnicode_FromStringPyBytes_FromString_PyArg_ParseTuple_SizeTcurl_easy_getinfoPyLong_FromLongPyList_AppendPyFloat_FromDoublecreate_and_set_error_objectPyList_SizePyUnicode_FromEncodedObjectPyText_AsStringAndSizePyText_CheckPyListOrTuple_CheckPyListOrTuple_SizePyListOrTuple_GetItemcurl_slist_appendPyLong_AsLongLongPyCFunction_TypePyFunction_TypePyType_IsSubtypecurl_formaddPyCallable_CheckPyMethod_Typedo_curl_setopt_filelikep_CurlShare_TypePyObject_GetAttrStringcurl_easy_performbytesiocurl_easy_pausePyErr_SetObjectdo_global_initcurl_global_initdo_global_cleanupcurl_global_cleanuppycurl_ssl_cleanupPyDict_GetItemPyDict_SetItemdo_version_infocurl_version_infoPyInit_pycurlcurl_global_sslsetp_CurlMulti_TypePyType_TypePyType_ReadyPyModule_Create2PyModule_GetDictPyErr_NewExceptionPyDict_SetItemStringPyDict_Newcurlmultiobject_constantscurlshareobject_constantscurl_versionstrlen__snprintf_chkPyExc_ImportErrorstringioPyErr_Occurredpycurl_ssl_initPyImport_ImportModuledo_multi_traversecurl_multi_cleanupdo_multi_setattrodo_multi_getattrocurlmultiobject_methodsdo_multi_clearpycurl_acquire_thread_multiPyGILState_EnsurePyExc_RuntimeWarningPyErr_WarnExPyGILState_Releasedo_multi_dealloccurl_multi_timeoutcurl_multi_performcurl_multi_socket_allcurl_multi_socket_actiondo_multi_newcurl_multi_initcurl_multi_assigncurl_multi_fdsetPyDict_DelItem_Py_TrueStructcurl_multi_add_handleselectcurl_multi_info_readPyUnicode_DecodeLocalecurl_multi_setoptmemsetPyExc_KeyErrorPyTuple_SizePyTuple_GetItemPyList_GetItemdo_share_traversedo_share_newshare_lock_newcurl_share_initshare_lock_callbackcurl_share_setoptshare_unlock_callbackcurl_share_cleanupdo_share_setattrodo_share_getattrocurlshareobject_methodsdo_share_cleardo_share_deallocshare_lock_destroyPyText_FromString_Ignorepycurl_get_thread_state_multiPyEval_AcquireThreadPyEval_ReleaseThreadshare_lock_lockPyThread_acquire_lockshare_lock_unlockPyThread_release_lockPyThread_allocate_lockPyThread_free_lockcurl_easy_strerrorlibssl.so.3libcrypto.so.3libcurl.so.4libc.so.6OPENSSL_3.0.0GLIBC_2.4GLIBC_2.3.4GLIBC_2.2.5$ORIGIN/../..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX2 +pdZ@ii rti |ui > +pdGp GpPP8PQQQR Rg@RG`RRRRRS  SU@SHS0`S!S+S8S0tSEStTRUfhWWWWWWXDXX YmY@IZZ6 Z4(ZC@ZHZM`ZhZ<ZZ?ZZ>ZZQZZ`;[[PB [C([0G@[H[@K`[8h[3[E[3[!`]h]^]]\]8]PZ]E] Z@IHIRPIXIpX`IhIpIxIIIIIIIIII I I I I IIQIJJJJ J(J0J8J@JHJPJXJ`JhJpJxJJJJJJ JJJ!JJ"J#J$J%J&J'JK(KK)K* K+(K,0K-8K.@K/HK0PK XK`K1hKRpK2xK3K4K5K\K6K7K8K:K;K<KK=KK>K?K@KLALBLCLD LE(LF0LPP8LG@LHHLIPLJXL`LKhLpLxLLLLLLLMLNLOLPLQLRLSLLLTLULVM(YM[MM M(MW0MX8MY@MZHM[PM\XM]`M^hMpMxM M_M`MRMaMbMcMdMMMMeMMMgMMhNiNjNkNl N(Nm0Nn8No@NpHNqPNrXNs`NthNupNvxNNwNxNyNzN{N|NN}NN~NNNNNNOOOO O(O0O8O@OHOPOXO`OhOpOxOOOOOOOOOOHROOOOOOO PPPPPPQ9pY9\9XQ`QfYf]fQQQRR(R8RXRhRxRRRRRR SS(S8SXShSxSSS0TUpWWWWWXXXXXXYxYYZ8ZXZxZ ZZZZ[8[X[P\X\p\x\\\x]]H'H5%@%bfHHUHtHH=HH9tHHtH=H5H)HHHHHHtHHt=Su(UH=Ht H=<Wy+]fATIUHSHHHt HՅH{0Ht LՅH{8Ht LՅHHt LՅxHHt LՅ_HHt LՅFHHt LՅ-HHt LՅHHt LՅHHt LՅHHt LՅHHt LՅHHt LՅHHt LՅ~HHt LՅeHHt LՅLHHt LՅ3HHt LՅHHt LՅHHt LՅH{HHt LՅH{PHt LՅH{XHt LՅH{`Ht LՅH{hHt LՅu~H{pHt LՅulH{xHt LՅuZHHt LՅuEHHt LՅu0HHt LՅuH{@1Ht[LH]A\@[]A\f.SHHHt}HCH~H[H@HHH5NjH8-1Hf.@HHH5NjH81Hf.@UH 1'SHHHH 1 HHHw'H{ Zu^H{ +BuF1H{ )-u1H HHt)1H{ "' H[]fDH lH5jH=jqfATIUHSXHHtH[]A\HH8t>H/[LHUHL]]HA\%SHHHtHCH{Ht HCHtHhH[H@HSHH98H10HHtdH@H(H9sfuHH9uHC HtH xH[H tHH5iH81H[HuH1HH DHxS1H ,kH5iH=4if.AT1IUSHGH0H+HH@H(H9sfD%HH9uI|$ HC HHH 1'H1 HHHw'H{ iI|$HtHCHbI$HtHH{ Hھ'H11I$HtHH{ Hھ-'H1I$HtHH{ Hھ'H1I$HtHH{ HھI'H1I$HtHH{ HھI'H1I$HtHH{ Hھo'H1ZI$HtHH{ Hھ'H1/I$HtHH{ Hھ'H1I$HtHH{ Hھ'H1I$HtHH{ Hھ'H1I$HtHH{ Hھ'H1I$HtHH{ Hھ'H1XI$HtHHI$HtHHI$HtHHI$HtHHI$HtHHID$HHtHHCHID$PHtHHCPID$XHtHHCXID$`HtHHC`ID$hHtHHChID$pHtHHCpID$xHtHHCxI$HtHHI$HtHHI$HtHHID$@HtHHC@H[]A\H{Ht HCHt&H t)HH5eH81H[]A\HH rfBH5dH=dAfUHSHHH?HtHt'HXH8HHtHhH[]@JH fH5dH=hdSfHnHfHnflHH@)$HtHt(HaH8HC@Htfo$PH[H egH5cH=cPSHt"HkHH0Wu*H[%PH qeH5JcH=cH QeH5*cH=aATIUHSHuH{L[H]A\%fATIUHSFtH} tCu 1[]A\fDHHtHLH5aH81fHLH5aH81CېAVAUIATUSHtHHtHCHq@t{Lc0MtrI|$ tXMtSID$(HC0Hx(E,I|$ LISLHC0HC(HtH@(HC0I $@HHtHǃHHHtHǃHuHHtHǃHEHHtHǃHHHtHǃHHHtHǃHHHtHǃHHHtHǃHUHHtHǃH%HHtHǃHHHtHǃHHHtHǃHD@tjHHtHǃHHHtHǃH HHtHǃHf.@@t*HHtHǃHZf.@t:Lc8Mt1I|$ HC8tMt1Ҿt'L1rI $@ tH{@HtHC@H@ŀt*HHtHǃHf.H{HHtHCHHjH{PHtHCPHH{XHtHCXHH{`HtHC`HH{hHtHChHH{pHtHCpHhH{xHtHCxH>HHtHǃHHHtHǃHHHtHǃHtR[]A\A]A^fL@L@ mN[]A\A]A^%fDzDjKDZEDJD:D*DD DDcD9DDDeD0DDzDjDZpDJ@D:D*DD D%DDH n]H5[H=#[]DATUSHHtHH0`Hk HC HtnHHHC(HH^HIL 1ҾHH{t+H[]A\%=DH{(uwH{0H{8u[]A\H s\BH5ZH=j[rH S\8H5ZH=pYRH 3\7H5|ZH=Z2H \?H5\ZH=ZH [AH5H(L[]A\A]A^A_H=NM1HHH1H;HMHHtaHCHu_ HسIHHH ;H-DDHT$Ht$HHD$HD$ùHT$ubHx]L9XHt$ILDH,fHH5PH8Ѷ#ALHLH5OH81@HD$HKHH5KHD$HHtHT$Ht$Hu=Lt$Mx3M9.Ht$LLзHMHʹLt$HMt&H޲HT$LH5NH81\HfDAVfI~USHH0L$Ht$ T$\$dH%(HD$(1H\$T$fInH=JL$HHtwH1HHMHHtS1H;tHCHtxJH tKH|$ HD$(dH+%(uZH0[]A^DH|$ HWDHGjfhAWAAVMAUIATIUHSHHdH%(HD$1HLHHMLLH=I1ӲHHt{H1HaHMHHtWE1H;utHCHt{ AH tMH<$۴HD$dH+%(u^HD[]A\A]A^A_ÐڵH<$AHDHffbA'f.DAULIATAULSHHdH%(HD$1Ht?Ht+مxHcH9tJHH5dLH8òH<$HD$dH+%(u~H1[]A\A]fDLDH= H1CHHt3H1HѮH Ht)HtHMuHxDH߰ATHAUSHHdH%(HD$1HHDH=&G1HH}H1HHMHHtY1H;(tHCu\H uBHH<$@HD$dH+%(uvH[]A\DH<$SfH_ŃvHH5JH8CrfDH<@AVHAUATUHSHHdH%(HD$1HHHwH HH<߬IHCHzIHrE1 fA111L.HHtFLH*H߉ϭuHcЅxHH u%eu <fګHcE~x HHH taHHH8L1H<$HT$dH+%(H[]A\A]A^%luL߮H<$e1HH5DH8HH5DH8[eH/H5vDH8߮IĮH HjH5DH=Df.fAWAVIAUATAUSHHc?{HD$HA$Hc$IFLuqt$F=wLHcƉHihH,)Љi')C%HHT$dH+%(u(H[HH5J:H8I1/AWAVAUIHH5;:ATUSHdH%(H$1HL$hHT$dHY:LZt$dF=HcƉHihH,)Љi')CH|$hH;=)CݗH|$hHGaAHD$hDt$dHD$A('Ax'o A7'e AV'_Am'e MepfDDL$DH|$5DL$HI'H$Dt$MELd$ Ld$HD$Ll$(%H H8 HI9'HLDHIHo Ht$LHHH HH$HtHuHD$HD$qHH5F8H81f\$d' /uHI} 1e H6HHD$HH$HHAH\$hH5,H{H9t+H;=̖t"l4H\$ht$d ft$dN oN|,NXNIHHtIDžHII} XNHZ1zI} L1I'ff~NN IHHtIDžHI} IN1HI} L1'DNl~ZN^N IHHtIDžH II} NHhNDN% IHHtIDžH I} IN1HI} L1' DL`H$dH+%(H[]A\A]A^A_Á+N IHHtIDžHU IHtIDžH I} I+N1HǗaI} L1'MHT$ht$dL:f.IHHtIDžH I} IN1HdI} L1'ҕpDIHHtIDžHe I} I~N1HܓI} L1o'rDIHHtIDžHG I} IN1H&I} L1'DDL$DHHD$pHD$xDL$HzHD$0H$DL$HE1H\$8HD$@Ll$PT$HLH|$HDŽ$HDŽ$HDŽ$HDŽ$gHHŅr HHA 1H/HL$8H$H$Hy H߾HHŅH$H$HH$* H|$pHt$xHjA1$j$jL$H$H$H0Ht HP H$Ht H'IL9d$@Ll$P('I} HT$p1ƅ HT$0Ht$pLuIHHtIDžH IHtIDžH{ I} I,N1HLI} L1'rDIHHtIDžHI} IN1Hܑ&I} L1'IHHtIDžHIHtIDžH^I} IoN1HI} L1-'5HkH5+H81|@A'k~9MA(H&H5o-H8v17A'A'uM^fDA''A,'uMe`9fH|$hH\$hHCH;Րt$dt'(HHL͑xDHAƅHّIHbIAHDH;LLD$HHLD$HHD$I@LD$ E1HD$(H$HD$Ld$X)f.AMcL9l$ L9l$(DLHH@PEgHDMcLcHELDHCHʊIŃ @t AEKDLHHL$H$H$HKPHL$HcH$HHȍMD(HPA H|$0H$HKL$LH|$0HcL$LHD$H$HH HPfDLH9HL$H$H$HHL$HcH$HHD(HPEA"HH$HHHPD$LD$L 1H{H5+H8ˌH|$H$Ht HHH|$p׌H|$0H\$0HHD$HHH)12Hy1fDMePGIHHtIDžHI} IN1HsI} L1'7HHdH5(H81uMeh@MexMMeXHH5(H8d1%DMeHga1 Dt$Ll$(IHLd$ 1I} DދLLHHHD$HhL$L1׉L$LHHD$0H$Ht HH|$H$Ht HH|$pˊ1T@L$LLDH5L$LHHH5)H8RHH5&H86fHD$HcLd$XH|$pHt$xHHA(jP1jL$H$KH$H Ht HH|$Im8HH;Cut'I} 11Jƅ1IE8HMHHH5$H8@HԉH5$H8$uHH5A$H8Ysp"H$Ll$PHt HLч^SQH.=2'ez*=eH$Ll$PHt H+L*[HH5@'H8H$Ht HH|$H$Ht HH|$p߇H;;HH;t'HS I} 10ƅtI]8HH$Ht HքgHH5$H81H$Ht H.HH5"H8݆.H$Ht HH[H5|#H8H$Ht HH)H5"H8yH H5%H8]1Lm_H|$pY΄ÄJ H|$p&1LxATIHUSH'H5 %_HH'oN-'uB1HH=$ H HtXHtCHLHMH[]A\@HH5"H8H 1H[]A\DHD+NtfDH5tU,NHHPHSH5"H81HD$HBHD$H[]A\@H'1bHH5z"H8Q1DfSHHH5P#H dH%(HD$1HL$HT$ >tiH|#H}uPH|$Nt*HT$t$ HaHT$dH+%(u$H [HYH5!H81SHHH5 #H@dH%(HD$81HT$H|$H|$HL$ HT$0Ht$(^HHtHǃHHD$ HtlHNH{ 1HcƅuW1H{ Hھ}'H\HHT$8dH+%(H@[HD$HfDHHtHǃHt|H1 ?DHH5 H811qfHHt$HǃHuD$ D$ fD@D$ t$ qǁf.DATHfUSH/u[HC(HtPfH{ I}LHC(uH H[]A\HuD1H "H5<"H=G"@UHSHH5ؑHHЀ1H8m}HHH¾'HHts1H|Ht^11H5!HH t H[]HD$HRHD$H[]fD1~H9HH^1뷐H uH1f.@U1SHZ~HHt11HeH HtHHH[]H~DAUATUSHHH5!HdH%(HD$1HT$H H)~Hk0Lk(HHE(HC0Hx(AH{ t$I~L|HC0HtH@(Lk(udH|HHT$dH+%(H[]A\A]HC(HuH b gH5H=A}fH H= 1}HHtH{HH8|H t1gHG}1Vr~H gH5rH=|f.HHH5dH%(HD$1HT$WtJHc|$w)u?H{HHT$dH+%(u@HH1zH5H8}1DHzH5~H8}1}f.DHN H1{HHÐHt f.%*|f.SHH;GzH[fDHH AVAUATUHSHIIIH|HHMt(HL|HHHLzumMt-M9t(HLw|HHHLyu;H t&HMt1[]A\A]A^DH?{DH/{DH tH{H|LHH81}H -FH5 H=tzH FH5H=ZDTzf.fAUIATIUHHSH|Ht/HLLHHkx 1H[]A\A]H t DH@zf.@ATHH5eUSHdH%(HD$1HT$D$ k||$yHHH@@1H8t HH<uxHHHC@AH8HtFf< t < uDGH< t< tyHBJD%HC@J< IHu xIH;{HH{ID$H< t < uGH< t< tKyHID$ {4{HH{ID$(H< t < ufDGH< t< txHdID$0Hc{ zHLH{(ID$8HuH< t< txHID$@H{0zHH{8ID$HHX< t < ufDGH< t< tKxHfHnfHnH{HflAD$PH< t < ufDGH< t< twHtpID$`Hc{PyHt\H{XID$hH< t< uGH< t< twHt%ID$pHD$dH+%(HL[]A\I $t HMtE1LwHwHuHHuHWHuH54H8"xHuH~HuHHuHHuHAwfDAWAVAUATUSH8HpudH%(H$(1HD$XH\L%tI$[L-)zI[ uHYxH-pHT$XHxHuL5BsHL=sHHxL0H$vL8HByL HHsL(HtHCIFIGID$IEwLzwjLiwLXwLGwXH=cwHD$H?YH|$lsHD$8HZ11H=m=wL-sHIEH.YH|$8H5KsXuHWrIHHYuL5[xIIHYYuH wHL$HHYuHHD$rHIHL%#xI$fDHT$XE11Ll$`L=mL5-HHt]fIwDMMOK|%HL)pL;H1sHIXZHT$XHcHHuHvLHH5A>H816sHvL-qHqL5*wHD$L%>wHWt1E1E1E1HD$0HqHD$(H,rHD$ HsHD$H;Ht HI>Ht HHD$H8Ht HI}Ht H Mt I Mt I-Mt IHD$0H8Ht HHD$(H8Ht HHt HMHD$ H8Ht HHD$H8Ht HI<$fptHHD$H$(dH+%(sWHD$H8[]A\A]A^A_HtL-oH{oL5uHD$L%ueHYtL-oHKoL5duHD$L%xu5LwqfjqDZqDHGqf:qD*qDLD$8LL$qLL$LD$8LD$8LL$pLD$8LL$LD$LL$pLD$LL$LD$LL$pLD$LL$LD$LpLD$LwpfHsH59H8q5@HPHsH H5:H81oHrL-FnHmL5sHD$L%sHrL-nHmL5sHD$L%s}HqrL-mHcmL5|sHD$L%sMD$`noneLl$`D$doL%csI$HHPycURL/7LHt$HH/7.45.3HHI $HyA HL$ rHL$ BD9I<$goIHH|$81HH&T 2qIHH|$81HH\TpIHSH|$81HH>tTHnHH L|$81HH'LUSHn1HLH2HqL|$81H(@HL Hk1H CLL|$8HL;pHHrH|$8HHL-TH+oIH9H|$8HHaHpSH+oIHH|$8HH7H7SH+1toIHH|$8HHH@SL;;oHHH|$8HHLSL;oHHXH|$8HHLSL;1nHH"H|$8HHLY>SL;nHHLL|$8HH]LRH3HHNL\L|$8H31H8L;H3H'LfH3HLGH3HL(H3HL H3HLH3HLH31H@LeH3QHLFH3HL'qH3,HLRH3.HL3H3$HLH3HLH3HLH3 HwLmH3HvLNH3-HhL/yH3H\LZH3HNL;H3!H=LH3 H,LH3FH$LH3IHLuH3HLVH3HL7H3@HLbH3HLCH3HL$H3HLH3HLH3HL}H3HL^H3HL?H3HL jH3 HLKH3 HL,H3 HwL H3 HoLH3 HgLH3H_LfH3HWLGH3HLL(rH3HBL SH3H<L4H3H,LH3H%LH3HLH3H LnH3HLOH3H L0zH3H L[H3H L L_H3RH3 L@H3BH& L!kH35H LLH36H L-H3[H LH3SH LH3<H LH3ZH LgH3PH LHH3$H L)sH3%H L TH3&H L5H3'H LH3(H LH3)H LH3*H LoH3+H LPH3-H L1{H3/H L\H30H L=H30Hx LH31Hq LH34Hi LH37HX LwH38HF LXH39H4 L9H3=H$ LdH3>H LEH3?H L&H3@H LH3AH LH3CH LH3<H L`H3DH LAH3EH L"lH3FH LMH3GH L.H3HH LH3IH LH3JHw LH3KHj LhH3LHY LIH3NHF L*tH3OH? L UH3TH& L6H3UH LH3VH LH3XH LH3WH LpH3 H LQH3YH L2|H3H L]H31H LAH3H L"H3H LH3H LH3H L{H3H L\H3HHx L;H3HHd LdH3HV LEH3HF L&H3H7 LH3H+ LH3H" LH3H L`H3 H LAH31H L%oH3H LPH3H L1H31H LH3H LH3H LH31H LqH3H LRH3H L3}H3H L^H31Hx LBH3Hi L#H3HV LH3 HC LH3 H0 L|H3H L]H3 H L>H3HLiH3HLJH31HL.H3HLH3HLH3HLH32HF LhH3`HLIH30H{L*tH3'H L UH3!'HIL6H3'H2LH3uHLH3*'H LH3HLpH3HLQH3H L2|H3'HL]H3'HL>H3'HkLH3'HZLH3'HILH3'H LxH3,NHLYH3 'HL:H3uHLeH3V'HLFH3 H L'H3'HLH3wHLH3"'HnLH3'HLaH3+NH:LBH3H)L#mH3HLNH3HL/H3'HLH3'HLH3'HLH3'HLiH3'HLJH3'HL+uH3'HL VH3;H|L7H3=HgLH3)HXLH3*H_LH3+H"LqH3,HLRH3-HL3}H3.H_L^H3/HGL?H30HL H32HLH33H}LH34HdLyH35HTLZH36HBL;H3uH'LfH3&'HfLGH3''HL(H3'HL H3HLH3HLH3HLbH3('HLCH3)'Hz L$nH3cHbLOH3dHVL0H3eHLH3fHLH3gH LH3iHLjH3uHLKH3vHL,vH3*'HL WH3HL8H3,'HLH37'HgLH3m'HRLH3-'H<LrH3oNH)LSH3NHL4~H3/'HL_H3 HL@H3!HL!H3"HLH34'HLH35'HLzH3N'HL[H3O'HpL<H3O'H[LgH3XNHELHH3NH7L)H3H)L H3'HLH3HLH3'HLcH3@HLDH3q'HIL%oH3Q'H7LPH3EHL1H3DHpLH3GH' LH3 H<LH3JH)LkH3KHLLH3\'HL-wH3]'HLXH3NHL9H3PHLH3QHjLH3b'HLH3c'HhLsH3THLTH3UHEL5H3f'HzL`H3g'HmLAH3h'H[L"H3*'HLH3i'HLH3ZHL{H3\HL\H3[HL=H3~NHLhH3bHLIH3H[L*H3cHNL H3t'HLH3eHLH3v'HLdH3v'HLEH3HL&pH3x'HLQH3iHL2H3jHLH3kHLH3nHLH3oH}LlH3pHhLMH3qH^L.xH3uHILYH3uH6L:H3uH(LH3uHLH3'HLH3wHLtH3uHLUH3yHL6H3HLaH3NHLBH3NHL#H3NHLH3NHLH3'HzL|H3HgL]H3'H L>H3'H?LiH3H/LJH3H!L+H3HL H3HLH3HLH3'HLeH3uHLFH3uHL'qH3HLRH3HL3H3HLH3'HLH3'HLH3'HLmH3NHoLNH3H`L/yH3HTLZH3H.L;H3H!LH3HLH3H LH3HLuH3HLVH3HL7H3HLbH3HLCH3HL$H3HLH3HLH3'HL}H3'HiL^H3(H]L?H3(HKL jH3(H9LKH3(H(L,H3(HL H3(HLH3(HLH3(HLfH3(HLGH3HL(rH3HL SH3(HL4H3HLH3(HLH3HLH3 (HLnH3 (HyLOH3 (HqL0zH38(HiL[H3(H[LL,H3H-Lî H3HL褮H3H L腮ϵH3HLfH3 HLGH3 HL(rH3 HL SH3 HL4H3HL˭H3HL謭H3HL荭״H31HLqH31HnLUH3H[L6H3HJLaH3'H=LBH3H*L٬#H3HL躬H3H L蛬H3HL|ƳH3(HL]H3. HL>1HL j1HLL1HL.11HLɫ1HL諫1HxL荫ײ1HkLo1HXLQ1HFL3}H1H5L`11H)LE1HLݪ'1HL迪 1HL衪1HL胪ͱ1HLe1HLG1HL)s1HL U1HL71HyLϩ1 HhL豩1@H_L蓩ݰ1 HOLu1HCLW1H7L91H(Le1HLG1H Lߨ)1HL 1HL裨1@HL腨ϯ1HLg1HLI1HL+u1HL W1 HL91 H}Lѧ1@HsL賧1@HZL蕧߮1HNLw1H5LY1H&L;1H Lg1HLI1HL+1HLæ 1HL襦1HL臦ѭ1HLi1HLK1HkL-w1 HZLY1 HAL;I6HH1LӥI6HH(L赥I61H'L虥I6HLzĬI6HL[I6HL<I6HHLhI6HLII6HL*I6HL I6HL袤Hl$HLHu}ǫHuHL]HuHL=HuHLgHuH{LGHuHqLݣ'HuHcL轣gH=LzIHH56H6H 'HL$0HHH5LH HL$(HHH=HxHD$H5HLL$HIHD$ H1H5H=LL$LD$ HHLL$@1LHLD$ LD$LL$@H IHHL$ HfHLD$@LL$ޠHD$ H|$8H5PH1HGH5^H=6LL$LD$@HHLL$H1LHLD$@qLD$@LL$HH 8HHL$HHOHL$H|$8H5HuZHL-H L5$ HD$L%8 HH5zH8qHL-CHL5HD$L%鮨@HHL5L%HD$鄨fHyL-HkL5HD$L%UHIHBL5[L%tHD$,H#1E1E1L54L%MHD$HaHD$0HHD$(HAHD$ HHD$!HH;1E1L%E1HD$HHD$0HHD$(HHD$ HjHD$H֧IpLbL%VHMLH>H _H5H=H ^H5H=DH ]H5gH=IϦLIL骦H AH5H=1HHD$ HSHD$馦IbLTIKL=I4Ly&HMHaHHD$(HQ1E1E1HD$ HHD$HMӥHťHMH魥HMH镥HMH}f.ATIUHSHHHt HՅu!H1Ht[LH]A\[]A\f.HHMH5H81Hf.@HHH5H8m1Hf.@ATUSHtKHo HG(HHt2EHC(HtHHILfC []A\H YH5UH= DH bH55H=߹$f.fSHthHHH0'u0H{(tH{ t[H H5H=@H H5H=H H5H=SfUHSHH_H{ H{(uMH H}(u]HE0H9tHu 1H[]HH5H8ԐHH5H8HqH5H8HXH5iH8hf.@ATIUHSHH{L[H]A\%f.ATIUSHaLHmHHt H[]A\DHH8tNHSLHHU[L}]HA\%SHH{(uHHH9H[@HiHH5{H811[@SHHHtHǃHthH{Ht HCHtZHHtHǃHtNHHtHǃHt 1[fD1[fDzAUHAATAULSHHdH%(HD$1HHtYHIHDDH=1HHtXH1HHMHHt4H H<$AHD$dH+%(uH1[]A\A]@BH5HH8 fH-QHE=HWHr@H?gl@UHHSHHdH%(HD$1HttHtGHH=1HHH1HHMH}HthH tSH<$!HD$dH+%(ugH1[]H56HH8fHWDH7udf.fUSHHQH5bH9t%OHHHtH[]D1HHtHǃHH{HtHCHHHtHǃHHHtHǃHHDH{t HtHH@HGHH[]%$@H{HXdHHZiDHHZiDHH{Z^fSHHdH%(HD$1H{ HH{(Hu.H4$H=A1[HT$dH+%(H[ÐHH=1(HHtH1HH8H t1@H1HHH5H811qH HmH5H81\1Jf.DATUSHHdH%(HD$1D$H{ H{(HC(HAH{ Ht$IL EHC(wWH x[H5H=b f.DATUSHHdH%(HD$1D$XH{ H{(HC(HH{ Ht$I LT EHC(w H (AH5(H=Ү f.DATUSHHH5?H dH%(HD$1HL$HT$ D$HH{ H{(O HC(H  H{ T$HL$t$ I L HC(u3T$1H=F1 HT$dH+%(H []A\ÐHzH=1x HHtH HH8 H t1@H7 1HT HH5fH81 1nH- HH5H81 1G H X*H5xH="g f.DHASHH98taH10HHtrH@HH9sDHH9u HHtC HC HtFH[H1HH  H\{1H uH1 H t;HH51H8( H DH5wH=ǝf H SHHH5H dH%(HD$1HL$HT$  tvHH{ HH{(u:HT$t$ HuHH)HHT$dH+%(H [HEH5H5WH811‰HH=1HHtHHH8UH uH1zHHH5H81X1S f.AWAVAUATUSHH8dH%(HD$(1D$$H{ LHC(HD$HHs0A1LHHHLHHL0LLHH{ LD$$LAƅ 1H$HK1IH1HD$HoD$$=BfI$HI$0HD$$AD9 EAF?DAIƃ?HL$ID$0LsIc| IHH<$H3IrLI$HiIc' IHHLukI4LI$0H+IcIHt8H|$HuIL[fDIHT$HHD$HHtJIMt\H $HHD$HHHD$(dH+%(*HD$H8[]A\A]A^A_@HIMufLDHH=N1HHt HHH8H t]HD$^fHgNfLW fHL$H4$L1H=uEHD$H"HAHFH5SH81{HH!H5H81VATUSHHH5HdH%(HD$1H|HH1H4$HH4$H~ +H9^0HC(H@`H{ IH$Hp LHC(HH4$H$H9X0 H@0H tLHHHT$dH+%(H[]A\DHH5H81DHDHH=1HHtHHH8H uHO1fH+H>HH4$(FH H5H=QH H5H=%vf.@ATUSHHH5HdH%(HD$1HlHH1H4$HH4$H~ +H9^0HHH$Hx0"HC(H/-H{ IH$Hp @LHC(u9H$HX0HHHHT$dH+%(H[]A\HH4$_H1H=+HHtHHH8H t1HW1|HqH5H81^fHQH5H8a1>DH %H5H=H H5H=/tf.fAVAUATUSHHH5>H0dH%(HD$(1HHT$D$HD$1eHH{ H{(PD$ff/f/tH,fH*\f/D$ Lf/YBHk0HH,fHn1fHnںflH)D$HLHLHL0HLHH{ LD$LLHkD$1x2LD$LLIƋD$HxL"HcHT$(dH+%(H0[]A\A]A^H1H5H8Q1DH!HH53H811@HH=f1HHtHHH8-H uH1OHHH5cH8101(H \H5H=H <H5H=AWAVAUATUHHH5SH8dH%(HD$(1HT$D$D$JT$HNH} HE(HD$H1IH1IHbD$PT$&HD$ L|$H$*fDLgD$PT$HD$ H} LHHHxH$1eH|$ HHH0CHt$ fH H5IHtxSH1Ht$ H=HHgHLkH HN ft$LL1H=37HD$IMtdLl$ItJHD$(dH+%(vH8L[]A\A]A^A_@H H5*H8E1LDLHHH5H81MIMthItSHH= 1sHHtH|HH8H oH6a1@LDLI $LI $tH HLH HH5fH=cUHHH5H81MfAWAVAUATUSHHH5ǚHhdH%(HD$X1HL$HHT$D<HH{ HLs(M Dd$DAD$=?uIcDHihH,)Di')ƒHD$HH-H9wHPHAąBLd$HI|$H;=ItH5H9tt9Ld$HD$D=!N=$NH;H5H8@H|$HULd$HuHMI9D$tfDHH5H8IE1fDHD$XdH+%(HhL[]A\A]A^A_fbHA1A~ !Lr-HH5H8A$NJwH{ D1HEIHHEiD$DH|$HD$4-'H|$HD$PDHD$HIHD$HI9,HHD$8HHD$ H HD$I9HD$8LxLIHL1HE1HD$PHD$(5@Ht$(Ht`HL$ JHD$PKDIL9|$H|$DL^HHD$H|$uH`H5YH8p1@HH9\$I|HtHuHHH5.H81fDH{ HU!N1H{ H1'I$L @H{ HU$N1H{ H1'I$L@A!N)A$01D1SfDA$N 1Ҿ$N1,H{ 1Ҿ'1HHeHǃHQFf.HH5H8@LH|$ H{ t$4HHEIV1Ҿ!N1oH{ 1Ҿ'1\HHHǃH>HH5H81RH=j1HHtHHH8*H t^1HD$ HD$8t$4HHD1H{ u>IH6fH=ʊ1-HHHH/H8H HUHSHHHt'HHu HuHt%HH[]DHtHHHuH{HH5H816H1[]f.UHSHHH?Ht4HHtH[]%Åu4H[]HT$MHT$HHHuHH8tHHH5SH81f.@HGHu Hf.ft u %%H SPlH5 H=Zft u %%H PzH5H=fHHHHt 1DHHH5H8 1Hf.@HHH5H81Hf.@H!SHH98H10HHH@HS0H9sHH9uHC(HHC HH1H1H{ Hھ1H{ H"H[H1HH qH<1H tHH51H8HGH 7H5 H=.H fJH5H= H F<H5H=H &NH5H=mH LH5H=MDSHt!H;HH0WuIH{(t"[H H5AH=ʃH H5!H=&H bH5H=fSHHH5`H dH%(HD$1HL$HT$ NH.T$ B=rvwpHc‰HihH,)i')CKH|$HGt9HH@Hw&t$ FwJH{ 1~H?HfH1H5H81HT$dH+%(u H [ÐHH5ZH8Q9SHWH{ HtHC HH[@ATIUHSHH{L[H]A\%f.ATIUSHLH-HHt H[]A\DHYH8tHSLHH[L]HA\%QHGHt HGHt 1HH1Hf.fU1SHHH5HukH{Ht HCHt}H{ HtHC H{( H{t HHuH@Ht,HH[]%hHHH+xH[]@2H{ HyATIUHSHHHGHu]HH5vHHHtcLHtH;Ht HHt'H[]A\fDHH[]A\%sD$ ~D$ H RH5H=fHH1dH%(HD$1HH$u"H$Ht#HT$dH+%(u H@1H +H5(H=4nfDHGHf.UH1H=օSHHHt1HHH HtHHH[]fHGDHHSHH0HC(Ht!H{ HS0HtHz(uR[@HS0Ht?HB(Ht6H{ Hz uH H5H=:T@1[H H5H=,@1H vH5qH=#|H VH5QH=^H 6H51H=>f.HtSHSHH0u=HC(Ht H{ t[1[H 2H5оH=ڴd@1H .H5H=c=DSH^HH1Ht [f.fSHNHH1Ht S[f.f%:f.1f.f.DH<%'f.DH<%L@AT@US1HHtwHDHtHHuH[]A\bLct%J|JDIAuH1H[]A\1fDATUSHtSIHHo@DH;HtHH9u[L]A\%,H EH5H=|H CH5ȼH=\@Hy(%~fDHz(%fDUSH Ƈ tXH CHHt4HH=1_HHtWHhHH8H t/H[]XHHHuDHH[]%HMuHH[]%HHsetopt(option, value) -> None Set curl share option. Corresponds to `curl_share_setopt`_ in libcurl, where *option* is specified with the ``CURLSHOPT_*`` constants in libcurl, except that the ``CURLSHOPT_`` prefix has been changed to ``SH_``. Currently, *value* must be one of: ``LOCK_DATA_COOKIE``, ``LOCK_DATA_DNS``, ``LOCK_DATA_SSL_SESSION`` or ``LOCK_DATA_CONNECT``. Example usage:: import pycurl curl = pycurl.Curl() s = pycurl.CurlShare() s.setopt(pycurl.SH_SHARE, pycurl.LOCK_DATA_COOKIE) s.setopt(pycurl.SH_SHARE, pycurl.LOCK_DATA_DNS) curl.setopt(pycurl.URL, 'https://curl.haxx.se') curl.setopt(pycurl.SHARE, s) curl.perform() curl.close() Raises pycurl.error exception upon failure. .. _curl_share_setopt: https://curl.haxx.se/libcurl/c/curl_share_setopt.htmlclose() -> None Close shared handle. Corresponds to `curl_share_cleanup`_ in libcurl. This method is automatically called by pycurl when a CurlShare object no longer has any references to it, but can also be called explicitly. .. _curl_share_cleanup: https://curl.haxx.se/libcurl/c/curl_share_cleanup.htmlCurlShare() -> New CurlShare object Creates a new :ref:`curlshareobject` which corresponds to a ``CURLSH`` handle in libcurl. CurlShare objects is what you pass as an argument to the SHARE option on :ref:`Curl objects `.version_info() -> tuple Returns a 12-tuple with the version info. Corresponds to `curl_version_info`_ in libcurl. Returns a tuple of information which is similar to the ``curl_version_info_data`` struct returned by ``curl_version_info()`` in libcurl. Example usage:: >>> import pycurl >>> pycurl.version_info() (3, '7.33.0', 467200, 'amd64-portbld-freebsd9.1', 33436, 'OpenSSL/0.9.8x', 0, '1.2.7', ('dict', 'file', 'ftp', 'ftps', 'gopher', 'http', 'https', 'imap', 'imaps', 'pop3', 'pop3s', 'rtsp', 'smtp', 'smtps', 'telnet', 'tftp'), None, 0, None) .. _curl_version_info: https://curl.haxx.se/libcurl/c/curl_version_info.htmlThis module implements an interface to the cURL library. Types: Curl() -> New object. Create a new curl object. CurlMulti() -> New object. Create a new curl multi object. CurlShare() -> New object. Create a new curl share object. Functions: global_init(option) -> None. Initialize curl environment. global_cleanup() -> None. Cleanup curl environment. version_info() -> tuple. Return version information.global_init(option) -> None Initialize curl environment. *option* is one of the constants pycurl.GLOBAL_SSL, pycurl.GLOBAL_WIN32, pycurl.GLOBAL_ALL, pycurl.GLOBAL_NOTHING, pycurl.GLOBAL_DEFAULT. Corresponds to `curl_global_init`_ in libcurl. .. _curl_global_init: https://curl.haxx.se/libcurl/c/curl_global_init.htmlglobal_cleanup() -> None Cleanup curl environment. Corresponds to `curl_global_cleanup`_ in libcurl. .. _curl_global_cleanup: https://curl.haxx.se/libcurl/c/curl_global_cleanup.htmltimeout() -> int Returns how long to wait for action before proceeding. Corresponds to `curl_multi_timeout`_ in libcurl. .. _curl_multi_timeout: https://curl.haxx.se/libcurl/c/curl_multi_timeout.htmlsocket_all() -> tuple Returns result from doing a socket_all() on the curl multi file descriptor with the given timeout.socket_action(sock_fd, ev_bitmask) -> (result, num_running_handles) Returns result from doing a socket_action() on the curl multi file descriptor with the given timeout. Corresponds to `curl_multi_socket_action`_ in libcurl. The return value is a two-element tuple. The first element is the return value of the underlying ``curl_multi_socket_action`` function, and it is always zero (``CURLE_OK``) because any other return value would cause ``socket_action`` to raise an exception. The second element is the number of running easy handles within this multi handle. When the number of running handles reaches zero, all transfers have completed. Note that if the number of running handles has decreased by one compared to the previous invocation, this is not mean the handle corresponding to the ``sock_fd`` provided as the argument to this function was the completed handle. .. _curl_multi_socket_action: https://curl.haxx.se/libcurl/c/curl_multi_socket_action.htmlsetopt(option, value) -> None Set curl multi option. Corresponds to `curl_multi_setopt`_ in libcurl. *option* specifies which option to set. PycURL defines constants corresponding to ``CURLMOPT_*`` constants in libcurl, except that the ``CURLMOPT_`` prefix is replaced with ``M_`` prefix. For example, ``CURLMOPT_PIPELINING`` is exposed in PycURL as ``pycurl.M_PIPELINING``. For convenience, ``CURLMOPT_*`` constants are also exposed on CurlMulti objects:: import pycurl m = pycurl.CurlMulti() m.setopt(pycurl.M_PIPELINING, 1) # Same as: m.setopt(m.M_PIPELINING, 1) *value* specifies the value to set the option to. Different options accept values of different types: - Options specified by `curl_multi_setopt`_ as accepting ``1`` or an integer value accept Python integers, long integers (on Python 2.x) and booleans:: m.setopt(pycurl.M_PIPELINING, True) m.setopt(pycurl.M_PIPELINING, 1) # Python 2.x only: m.setopt(pycurl.M_PIPELINING, 1L) - ``*FUNCTION`` options accept a function. Supported callbacks are ``CURLMOPT_SOCKETFUNCTION`` AND ``CURLMOPT_TIMERFUNCTION``. Please refer to the PycURL test suite for examples on using the callbacks. Raises TypeError when the option value is not of a type accepted by the respective option, and pycurl.error exception when libcurl rejects the option or its value. .. _curl_multi_setopt: https://curl.haxx.se/libcurl/c/curl_multi_setopt.htmlselect([timeout]) -> number of ready file descriptors or 0 on timeout Returns result from doing a select() on the curl multi file descriptor with the given timeout. This is a convenience function which simplifies the combined use of ``fdset()`` and the ``select`` module. Example usage:: import pycurl c = pycurl.Curl() c.setopt(pycurl.URL, "https://curl.haxx.se") m = pycurl.CurlMulti() m.add_handle(c) while 1: ret, num_handles = m.perform() if ret != pycurl.E_CALL_MULTI_PERFORM: break while num_handles: ret = m.select(1.0) if ret == 0: continue while 1: ret, num_handles = m.perform() if ret != pycurl.E_CALL_MULTI_PERFORM: breakremove_handle(Curl object) -> None Corresponds to `curl_multi_remove_handle`_ in libcurl. This method removes an existing and valid Curl object from the CurlMulti object. .. _curl_multi_remove_handle: https://curl.haxx.se/libcurl/c/curl_multi_remove_handle.htmlperform() -> tuple of status and the number of active Curl objects Corresponds to `curl_multi_perform`_ in libcurl. .. _curl_multi_perform: https://curl.haxx.se/libcurl/c/curl_multi_perform.htmlinfo_read([max_objects]) -> tuple(number of queued messages, a list of successful objects, a list of failed objects) Corresponds to the `curl_multi_info_read`_ function in libcurl. This method extracts at most *max* messages from the multi stack and returns them in two lists. The first list contains the handles which completed successfully and the second list contains a tuple *(curl object, curl error number, curl error message)* for each failed curl object. The curl error message is returned as a Python string which is decoded from the curl error string using the `surrogateescape`_ error handler. The number of queued messages after this method has been called is also returned. .. _curl_multi_info_read: https://curl.haxx.se/libcurl/c/curl_multi_info_read.html .. _surrogateescape: https://www.python.org/dev/peps/pep-0383/fdset() -> tuple of lists with active file descriptors, readable, writeable, exceptions Returns a tuple of three lists that can be passed to the select.select() method. Corresponds to `curl_multi_fdset`_ in libcurl. This method extracts the file descriptor information from a CurlMulti object. The returned lists can be used with the ``select`` module to poll for events. Example usage:: import pycurl c = pycurl.Curl() c.setopt(pycurl.URL, "https://curl.haxx.se") m = pycurl.CurlMulti() m.add_handle(c) while 1: ret, num_handles = m.perform() if ret != pycurl.E_CALL_MULTI_PERFORM: break while num_handles: apply(select.select, m.fdset() + (1,)) while 1: ret, num_handles = m.perform() if ret != pycurl.E_CALL_MULTI_PERFORM: break .. _curl_multi_fdset: https://curl.haxx.se/libcurl/c/curl_multi_fdset.htmlclose() -> None Corresponds to `curl_multi_cleanup`_ in libcurl. This method is automatically called by pycurl when a CurlMulti object no longer has any references to it, but can also be called explicitly. .. _curl_multi_cleanup: https://curl.haxx.se/libcurl/c/curl_multi_cleanup.htmlassign(sock_fd, object) -> None Creates an association in the multi handle between the given socket and a private object in the application. Corresponds to `curl_multi_assign`_ in libcurl. .. _curl_multi_assign: https://curl.haxx.se/libcurl/c/curl_multi_assign.htmladd_handle(Curl object) -> None Corresponds to `curl_multi_add_handle`_ in libcurl. This method adds an existing and valid Curl object to the CurlMulti object. *Changed in version 7.43.0.2:* add_handle now ensures that the Curl object is not garbage collected while it is being used by a CurlMulti object. Previously application had to maintain an outstanding reference to the Curl object to keep it from being garbage collected. .. _curl_multi_add_handle: https://curl.haxx.se/libcurl/c/curl_multi_add_handle.htmlCurlMulti() -> New CurlMulti object Creates a new :ref:`curlmultiobject` which corresponds to a ``CURLM`` handle in libcurl.unsetopt(option) -> None Reset curl session option to its default value. Only some curl options may be reset via this method. libcurl does not provide a general way to reset a single option to its default value; :py:meth:`pycurl.Curl.reset` resets all options to their default values, otherwise :py:meth:`pycurl.Curl.setopt` must be called with whatever value is the default. For convenience, PycURL provides this unsetopt method to reset some of the options to their default values. Raises pycurl.error exception on failure. ``c.unsetopt(option)`` is equivalent to ``c.setopt(option, None)``.setopt_string(option, value) -> None Set curl session option to a string value. This method allows setting string options that are not officially supported by PycURL, for example because they did not exist when the version of PycURL being used was released. :py:meth:`pycurl.Curl.setopt` should be used for setting options that PycURL knows about. **Warning:** No checking is performed that *option* does, in fact, expect a string value. Using this method incorrectly can crash the program and may lead to a security vulnerability. Furthermore, it is on the application to ensure that the *value* object does not get garbage collected while libcurl is using it. libcurl copies most string options but not all; one option whose value is not copied by libcurl is `CURLOPT_POSTFIELDS`_. *option* would generally need to be given as an integer literal rather than a symbolic constant. *value* can be a binary string or a Unicode string using ASCII code points, same as with string options given to PycURL elsewhere. Example setting URL via ``setopt_string``:: import pycurl c = pycurl.Curl() c.setopt_string(10002, "http://www.python.org/") .. _CURLOPT_POSTFIELDS: https://curl.haxx.se/libcurl/c/CURLOPT_POSTFIELDS.htmlsetopt(option, value) -> None Set curl session option. Corresponds to `curl_easy_setopt`_ in libcurl. *option* specifies which option to set. PycURL defines constants corresponding to ``CURLOPT_*`` constants in libcurl, except that the ``CURLOPT_`` prefix is removed. For example, ``CURLOPT_URL`` is exposed in PycURL as ``pycurl.URL``, with some exceptions as detailed below. For convenience, ``CURLOPT_*`` constants are also exposed on the Curl objects themselves:: import pycurl c = pycurl.Curl() c.setopt(pycurl.URL, "http://www.python.org/") # Same as: c.setopt(c.URL, "http://www.python.org/") The following are exceptions to option constant naming convention: - ``CURLOPT_FILETIME`` is mapped as ``pycurl.OPT_FILETIME`` - ``CURLOPT_CERTINFO`` is mapped as ``pycurl.OPT_CERTINFO`` - ``CURLOPT_COOKIELIST`` is mapped as ``pycurl.COOKIELIST`` and, as of PycURL 7.43.0.2, also as ``pycurl.OPT_COOKIELIST`` - ``CURLOPT_RTSP_CLIENT_CSEQ`` is mapped as ``pycurl.OPT_RTSP_CLIENT_CSEQ`` - ``CURLOPT_RTSP_REQUEST`` is mapped as ``pycurl.OPT_RTSP_REQUEST`` - ``CURLOPT_RTSP_SERVER_CSEQ`` is mapped as ``pycurl.OPT_RTSP_SERVER_CSEQ`` - ``CURLOPT_RTSP_SESSION_ID`` is mapped as ``pycurl.OPT_RTSP_SESSION_ID`` - ``CURLOPT_RTSP_STREAM_URI`` is mapped as ``pycurl.OPT_RTSP_STREAM_URI`` - ``CURLOPT_RTSP_TRANSPORT`` is mapped as ``pycurl.OPT_RTSP_TRANSPORT`` *value* specifies the value to set the option to. Different options accept values of different types: - Options specified by `curl_easy_setopt`_ as accepting ``1`` or an integer value accept Python integers, long integers (on Python 2.x) and booleans:: c.setopt(pycurl.FOLLOWLOCATION, True) c.setopt(pycurl.FOLLOWLOCATION, 1) # Python 2.x only: c.setopt(pycurl.FOLLOWLOCATION, 1L) - Options specified as accepting strings by ``curl_easy_setopt`` accept byte strings (``str`` on Python 2, ``bytes`` on Python 3) and Unicode strings with ASCII code points only. For more information, please refer to :ref:`unicode`. Example:: c.setopt(pycurl.URL, "http://www.python.org/") c.setopt(pycurl.URL, u"http://www.python.org/") # Python 3.x only: c.setopt(pycurl.URL, b"http://www.python.org/") - ``HTTP200ALIASES``, ``HTTPHEADER``, ``POSTQUOTE``, ``PREQUOTE``, ``PROXYHEADER`` and ``QUOTE`` accept a list or tuple of strings. The same rules apply to these strings as do to string option values. Example:: c.setopt(pycurl.HTTPHEADER, ["Accept:"]) c.setopt(pycurl.HTTPHEADER, ("Accept:",)) - ``READDATA`` accepts a file object or any Python object which has a ``read`` method. On Python 2, a file object will be passed directly to libcurl and may result in greater transfer efficiency, unless PycURL has been compiled with ``AVOID_STDIO`` option. On Python 3 and on Python 2 when the value is not a true file object, ``READDATA`` is emulated in PycURL via ``READFUNCTION``. The file should generally be opened in binary mode. Example:: f = open('file.txt', 'rb') c.setopt(c.READDATA, f) - ``WRITEDATA`` and ``WRITEHEADER`` accept a file object or any Python object which has a ``write`` method. On Python 2, a file object will be passed directly to libcurl and may result in greater transfer efficiency, unless PycURL has been compiled with ``AVOID_STDIO`` option. On Python 3 and on Python 2 when the value is not a true file object, ``WRITEDATA`` is emulated in PycURL via ``WRITEFUNCTION``. The file should generally be opened in binary mode. Example:: f = open('/dev/null', 'wb') c.setopt(c.WRITEDATA, f) - ``*FUNCTION`` options accept a function. Supported callbacks are documented in :ref:`callbacks`. Example:: # Python 2 import StringIO b = StringIO.StringIO() c.setopt(pycurl.WRITEFUNCTION, b.write) - ``SHARE`` option accepts a :ref:`curlshareobject`. It is possible to set integer options - and only them - that PycURL does not know about by using the numeric value of the option constant directly. For example, ``pycurl.VERBOSE`` has the value 42, and may be set as follows:: c.setopt(42, 1) *setopt* can reset some options to their default value, performing the job of :py:meth:`pycurl.Curl.unsetopt`, if ``None`` is passed for the option value. The following two calls are equivalent:: c.setopt(c.URL, None) c.unsetopt(c.URL) Raises TypeError when the option value is not of a type accepted by the respective option, and pycurl.error exception when libcurl rejects the option or its value. .. _curl_easy_setopt: https://curl.haxx.se/libcurl/c/curl_easy_setopt.htmlset_ca_certs() -> None Load ca certs from provided unicode string. Note that certificates will be added only when cURL starts new connection.reset() -> None Reset all options set on curl handle to default values, but preserves live connections, session ID cache, DNS cache, cookies, and shares. Corresponds to `curl_easy_reset`_ in libcurl. .. _curl_easy_reset: https://curl.haxx.se/libcurl/c/curl_easy_reset.htmlperform_rs() -> response_body Perform a file transfer and return response body as a string. On Python 2, this method arranges for response body to be saved in a StringIO instance, then invokes :ref:`perform ` to perform the file transfer, then returns the value of the StringIO instance. This behavior is identical to :ref:`perform_rb `. On Python 3, this method arranges for response body to be saved in a BytesIO instance, then invokes :ref:`perform ` to perform the file transfer, then decodes the response body in Python's default encoding and returns the decoded body as a Unicode string (``str`` instance). *Note:* decoding happens after the transfer finishes, thus an encoding error implies the transfer/network operation succeeded. Any transfer errors raise ``pycurl.error`` exception, just like in :ref:`perform `. Use :ref:`perform_rb ` to retrieve response body as a byte string (``bytes`` instance on Python 3) without attempting to decode it. Raises ``pycurl.error`` exception upon failure. *Added in version 7.43.0.2.*perform_rb() -> response_body Perform a file transfer and return response body as a byte string. This method arranges for response body to be saved in a StringIO (Python 2) or BytesIO (Python 3) instance, then invokes :ref:`perform ` to perform the file transfer, then returns the value of the StringIO/BytesIO instance which is a ``str`` instance on Python 2 and ``bytes`` instance on Python 3. Errors during transfer raise ``pycurl.error`` exceptions just like in :ref:`perform `. Use :ref:`perform_rs ` to retrieve response body as a string (``str`` instance on both Python 2 and 3). Raises ``pycurl.error`` exception upon failure. *Added in version 7.43.0.2.*perform() -> None Perform a file transfer. Corresponds to `curl_easy_perform`_ in libcurl. Raises pycurl.error exception upon failure. .. _curl_easy_perform: https://curl.haxx.se/libcurl/c/curl_easy_perform.htmlpause(bitmask) -> None Pause or unpause a curl handle. Bitmask should be a value such as PAUSE_RECV or PAUSE_CONT. Corresponds to `curl_easy_pause`_ in libcurl. The argument should be derived from the ``PAUSE_RECV``, ``PAUSE_SEND``, ``PAUSE_ALL`` and ``PAUSE_CONT`` constants. Raises pycurl.error exception upon failure. .. _curl_easy_pause: https://curl.haxx.se/libcurl/c/curl_easy_pause.htmlgetinfo_raw(option) -> Result Extract and return information from a curl session, returning string data as byte strings. Corresponds to `curl_easy_getinfo`_ in libcurl. The ``getinfo_raw`` method should not be called unless ``perform`` has been called and finished. *option* is a constant corresponding to one of the ``CURLINFO_*`` constants in libcurl. Most option constant names match the respective ``CURLINFO_*`` constant names with the ``CURLINFO_`` prefix removed, for example ``CURLINFO_CONTENT_TYPE`` is accessible as ``pycurl.CONTENT_TYPE``. Exceptions to this rule are as follows: - ``CURLINFO_FILETIME`` is mapped as ``pycurl.INFO_FILETIME`` - ``CURLINFO_COOKIELIST`` is mapped as ``pycurl.INFO_COOKIELIST`` - ``CURLINFO_CERTINFO`` is mapped as ``pycurl.INFO_CERTINFO`` - ``CURLINFO_RTSP_CLIENT_CSEQ`` is mapped as ``pycurl.INFO_RTSP_CLIENT_CSEQ`` - ``CURLINFO_RTSP_CSEQ_RECV`` is mapped as ``pycurl.INFO_RTSP_CSEQ_RECV`` - ``CURLINFO_RTSP_SERVER_CSEQ`` is mapped as ``pycurl.INFO_RTSP_SERVER_CSEQ`` - ``CURLINFO_RTSP_SESSION_ID`` is mapped as ``pycurl.INFO_RTSP_SESSION_ID`` The type of return value depends on the option, as follows: - Options documented by libcurl to return an integer value return a Python integer (``long`` on Python 2, ``int`` on Python 3). - Options documented by libcurl to return a floating point value return a Python ``float``. - Options documented by libcurl to return a string value return a Python byte string (``str`` on Python 2, ``bytes`` on Python 3). The string contains whatever data libcurl returned. Use :ref:`getinfo ` to retrieve this data as a Unicode string on Python 3. - ``SSL_ENGINES`` and ``INFO_COOKIELIST`` return a list of byte strings. The same encoding caveats apply; use :ref:`getinfo ` to retrieve the data as a list of potentially Unicode strings. - ``INFO_CERTINFO`` returns a list with one element per certificate in the chain, starting with the leaf; each element is a sequence of *(key, value)* tuples where both ``key`` and ``value`` are byte strings. String encoding caveats apply; use :ref:`getinfo ` to retrieve certificate data as potentially Unicode strings. On Python 2, ``getinfo`` and ``getinfo_raw`` behave identically. Example usage:: import pycurl c = pycurl.Curl() c.setopt(pycurl.OPT_CERTINFO, 1) c.setopt(pycurl.URL, "https://python.org") c.setopt(pycurl.FOLLOWLOCATION, 1) c.perform() print(c.getinfo_raw(pycurl.HTTP_CODE)) # --> 200 print(c.getinfo_raw(pycurl.EFFECTIVE_URL)) # --> b"https://www.python.org/" certinfo = c.getinfo_raw(pycurl.INFO_CERTINFO) print(certinfo) # --> [((b'Subject', b'C = AU, ST = Some-State, O = PycURL test suite, CN = localhost'), (b'Issuer', b'C = AU, ST = Some-State, O = PycURL test suite, OU = localhost, CN = localhost'), (b'Version', b'0'), ...)] Raises pycurl.error exception upon failure. *Added in version 7.43.0.2.* .. _curl_easy_getinfo: https://curl.haxx.se/libcurl/c/curl_easy_getinfo.htmlgetinfo(option) -> Result Extract and return information from a curl session, decoding string data in Python's default encoding at the time of the call. Corresponds to `curl_easy_getinfo`_ in libcurl. The ``getinfo`` method should not be called unless ``perform`` has been called and finished. *option* is a constant corresponding to one of the ``CURLINFO_*`` constants in libcurl. Most option constant names match the respective ``CURLINFO_*`` constant names with the ``CURLINFO_`` prefix removed, for example ``CURLINFO_CONTENT_TYPE`` is accessible as ``pycurl.CONTENT_TYPE``. Exceptions to this rule are as follows: - ``CURLINFO_FILETIME`` is mapped as ``pycurl.INFO_FILETIME`` - ``CURLINFO_COOKIELIST`` is mapped as ``pycurl.INFO_COOKIELIST`` - ``CURLINFO_CERTINFO`` is mapped as ``pycurl.INFO_CERTINFO`` - ``CURLINFO_RTSP_CLIENT_CSEQ`` is mapped as ``pycurl.INFO_RTSP_CLIENT_CSEQ`` - ``CURLINFO_RTSP_CSEQ_RECV`` is mapped as ``pycurl.INFO_RTSP_CSEQ_RECV`` - ``CURLINFO_RTSP_SERVER_CSEQ`` is mapped as ``pycurl.INFO_RTSP_SERVER_CSEQ`` - ``CURLINFO_RTSP_SESSION_ID`` is mapped as ``pycurl.INFO_RTSP_SESSION_ID`` The type of return value depends on the option, as follows: - Options documented by libcurl to return an integer value return a Python integer (``long`` on Python 2, ``int`` on Python 3). - Options documented by libcurl to return a floating point value return a Python ``float``. - Options documented by libcurl to return a string value return a Python string (``str`` on Python 2 and Python 3). On Python 2, the string contains whatever data libcurl returned. On Python 3, the data returned by libcurl is decoded using the default string encoding at the time of the call. If the data cannot be decoded using the default encoding, ``UnicodeDecodeError`` is raised. Use :ref:`getinfo_raw ` to retrieve the data as ``bytes`` in these cases. - ``SSL_ENGINES`` and ``INFO_COOKIELIST`` return a list of strings. The same encoding caveats apply; use :ref:`getinfo_raw ` to retrieve the data as a list of byte strings. - ``INFO_CERTINFO`` returns a list with one element per certificate in the chain, starting with the leaf; each element is a sequence of *(key, value)* tuples where both ``key`` and ``value`` are strings. String encoding caveats apply; use :ref:`getinfo_raw ` to retrieve certificate data as byte strings. On Python 2, ``getinfo`` and ``getinfo_raw`` behave identically. Example usage:: import pycurl c = pycurl.Curl() c.setopt(pycurl.OPT_CERTINFO, 1) c.setopt(pycurl.URL, "https://python.org") c.setopt(pycurl.FOLLOWLOCATION, 1) c.perform() print(c.getinfo(pycurl.HTTP_CODE)) # --> 200 print(c.getinfo(pycurl.EFFECTIVE_URL)) # --> "https://www.python.org/" certinfo = c.getinfo(pycurl.INFO_CERTINFO) print(certinfo) # --> [(('Subject', 'C = AU, ST = Some-State, O = PycURL test suite, CN = localhost'), ('Issuer', 'C = AU, ST = Some-State, O = PycURL test suite, OU = localhost, CN = localhost'), ('Version', '0'), ...)] Raises pycurl.error exception upon failure. .. _curl_easy_getinfo: https://curl.haxx.se/libcurl/c/curl_easy_getinfo.htmlerrstr_raw() -> byte string Return the internal libcurl error buffer of this handle as a byte string. Return value is a ``str`` instance on Python 2 and ``bytes`` instance on Python 3. Unlike :ref:`errstr_raw `, ``errstr_raw`` allows reading libcurl error buffer in Python 3 when its contents is not valid in Python's default encoding. On Python 2, ``errstr`` and ``errstr_raw`` behave identically. *Added in version 7.43.0.2.*errstr() -> string Return the internal libcurl error buffer of this handle as a string. Return value is a ``str`` instance on all Python versions. On Python 3, error buffer data is decoded using Python's default encoding at the time of the call. If this decoding fails, ``UnicodeDecodeError`` is raised. Use :ref:`errstr_raw ` to retrieve the error buffer as a byte string in this case. On Python 2, ``errstr`` and ``errstr_raw`` behave identically.duphandle() -> Curl Clone a curl handle. This function will return a new curl handle, a duplicate, using all the options previously set in the input curl handle. Both handles can subsequently be used independently. The new handle will not inherit any state information, no connections, no SSL sessions and no cookies. It also will not inherit any share object states or options (it will be made as if SHARE was unset). Corresponds to `curl_easy_duphandle`_ in libcurl. Example usage:: import pycurl curl = pycurl.Curl() curl.setopt(pycurl.URL, "https://python.org") dup = curl.duphandle() curl.perform() dup.perform() .. _curl_easy_duphandle: https://curl.se/libcurl/c/curl_easy_duphandle.htmlclose() -> None Close handle and end curl session. Corresponds to `curl_easy_cleanup`_ in libcurl. This method is automatically called by pycurl when a Curl object no longer has any references to it, but can also be called explicitly. .. _curl_easy_cleanup: https://curl.haxx.se/libcurl/c/curl_easy_cleanup.htmlCurl() -> New Curl object Creates a new :ref:`curlobject` which corresponds to a ``CURL`` handle in libcurl. Curl objects automatically set CURLOPT_VERBOSE to 0, CURLOPT_NOPROGRESS to 1, provide a default CURLOPT_USERAGENT and setup CURLOPT_ERRORBUFFER to point to a private error buffer. Implicitly calls :py:func:`pycurl.global_init` if the latter has not yet been called.Curl objects do not support deserializationCurl objects do not support serializationPyObject_IsInstance((PyObject *) self, (PyObject *) p_Curl_Type) == 1cannot invoke %s() - no curl handlecannot invoke %s() - perform() is currently runningself->multi_stack->state != ((void *)0)self->multi_stack == ((void *)0)pycurl_get_thread_state(self) == ((void *)0)src/easy.cg_pycurl_useragent*ptr == 0initializing curl failedcloning curl failed*old != ((void *)0)obj->httppost != ((void *)0)self != ((void *)0)self->state == ((void *)0)self->share == ((void *)0)closeresetting curl failedpycurl.Curlerrstrerrstr_rawperformperform_rbperform_rssetopt_stringresetduphandleset_ca_certs__getstate____setstate__pycurl.CurlHttppostpycurl.CurlSlistdo_curl_clearutil_curl_closeutil_curl_xdecrefdo_curl_duphandleutil_curl_initdo_curl_newassert_curl_stateutil_curlhttppost_updateutil_curlslist_update(y#i)(yi)(y#)(si)(siii)Unsupported address family(iiiN)(iN)fileno(ii)(i)(OOi)(L,i)strictascii(dddd)(LLLL)(iy#)Empty certificate dataCertificate data is too long.Can't allocate buffersrc/easycb.cstore != ((void *)0)integer overflow in write callbackwrite callback must return int or NoneOpen socket callback returned an object whose fileno method did not return an integerOpen socket callback's return value must be a socketsockopt callback returned %s which is not an integer closesocket callback returned %s which is not an integer ssh key callback returned %s which is not an integer invalid return value for seek callback %d not in (0, 1, 2)seek callback must return 0 (CURL_SEEKFUNC_OK), 1 (CURL_SEEKFUNC_FAIL), 2 (CURL_SEEKFUNC_CANTSEEK) or Noneinteger overflow in read callbackinvalid return value for read callback (%ld bytes returned when at most %ld bytes were wanted)invalid return value for read callback (%ld bytes returned after encoding to utf-8 when at most %ld bytes were wanted)read callback must return a byte string or Unicode string with ASCII code points onlyinteger overflow in debug callbackioctl callback returned invalid valueadd_ca_certss#sy#yi:getinfo_rawinvalid argument to getinfoi:getinfosrc/easyinfo.cPyType_HasFeature(Py_TYPE(((PyObject*)((list)))), (1UL << 25))decode_string_liststrings are not supported for this optionunsetopt() is not supported for this optionintegers are not supported for this optionlist items must be list or tuple objectslist or tuple must contain two elements (name, value)list or tuple must contain a byte string or Unicode string with ASCII code points only as first elementlist or tuple must contain at least one option and one valuelist or tuple must contain an even number of itemsvalue must be a byte string or a Unicode string with ASCII code points onlyunsupported second type in tuplelists are not supported for this optionlist items must be byte strings or Unicode strings with ASCII code points onlyfunctions are not supported for this optionCurl object already sharing. Unshare first.objects are not supported for this optionobject given without a read methodobject given without a write methodinvalid arguments to setopt_stringset_ca_certs argument must be a byte string or a Unicode string with ASCII code points onlysrc/easyopt.cstr != ((void *)0)i:unsetoptinvalid arguments to unsetoptiO:setoptexpected valueoption must be an integerunsupported optioninvalid arguments to setoptwrite(iO)O:cadataؽؽؽXؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽPؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽؽdo_curl_setopt_string_implsrc/easyperform.cself->state != ((void *)0)getvaluei:pausepause/unpause failed(is)do_curl_pausedo_curl_performi:global_initinvalid option to global_initunable to set global optionSymbol already defined: %s src/module.c|i:version_infounable to get version info, 8.5.0openssl%s%spycurl.errorversionCOMPILE_PY_VERSION_HEXCOMPILE_LIBCURL_VERSION_NUMCOMPILE_SSL_LIBREADFUNC_ABORTREADFUNC_PAUSEWRITEFUNC_PAUSEIOE_OKIOE_UNKNOWNCMDIOE_FAILRESTARTIOCMD_NOPIOCMD_RESTARTREADSOCKET_BADINFOTYPE_TEXTINFOTYPE_HEADER_ININFOTYPE_HEADER_OUTINFOTYPE_DATA_ININFOTYPE_DATA_OUTINFOTYPE_SSL_DATA_ININFOTYPE_SSL_DATA_OUTE_AGAINE_ALREADY_COMPLETEE_BAD_CALLING_ORDERE_BAD_PASSWORD_ENTEREDE_FTP_BAD_DOWNLOAD_RESUMEE_FTP_COULDNT_SET_TYPEE_FTP_PARTIAL_FILEE_FTP_USER_PASSWORD_INCORRECTE_HTTP_NOT_FOUNDE_HTTP_PORT_FAILEDE_MALFORMAT_USERE_QUOTE_ERRORE_RANGE_ERRORE_REMOTE_ACCESS_DENIEDE_REMOTE_DISK_FULLE_REMOTE_FILE_EXISTSE_UPLOAD_FAILEDE_URL_MALFORMAT_USERE_USE_SSL_FAILEDE_UNSUPPORTED_PROTOCOLE_FAILED_INITE_URL_MALFORMATE_NOT_BUILT_INE_COULDNT_RESOLVE_PROXYE_COULDNT_RESOLVE_HOSTE_COULDNT_CONNECTE_FTP_WEIRD_SERVER_REPLYE_FTP_ACCESS_DENIEDE_FTP_ACCEPT_FAILEDE_FTP_WEIRD_PASS_REPLYE_FTP_WEIRD_USER_REPLYE_FTP_WEIRD_PASV_REPLYE_FTP_WEIRD_227_FORMATE_FTP_CANT_GET_HOSTE_FTP_CANT_RECONNECTE_FTP_COULDNT_SET_BINARYE_PARTIAL_FILEE_FTP_COULDNT_RETR_FILEE_FTP_WRITE_ERRORE_FTP_QUOTE_ERRORE_HTTP_RETURNED_ERRORE_WRITE_ERRORE_FTP_COULDNT_STOR_FILEE_READ_ERRORE_OUT_OF_MEMORYE_OPERATION_TIMEOUTEDE_OPERATION_TIMEDOUTE_FTP_COULDNT_SET_ASCIIE_FTP_PORT_FAILEDE_FTP_COULDNT_USE_RESTE_FTP_COULDNT_GET_SIZEE_HTTP_RANGE_ERRORE_HTTP_POST_ERRORE_SSL_CACERTE_SSL_CACERT_BADFILEE_SSL_CERTPROBLEME_SSL_CIPHERE_SSL_CONNECT_ERRORE_SSL_CRL_BADFILEE_SSL_ENGINE_INITFAILEDE_SSL_ENGINE_NOTFOUNDE_SSL_ENGINE_SETFAILEDE_SSL_INVALIDCERTSTATUSE_SSL_ISSUER_ERRORE_SSL_PEER_CERTIFICATEE_SSL_PINNEDPUBKEYNOTMATCHE_SSL_SHUTDOWN_FAILEDE_BAD_DOWNLOAD_RESUMEE_FILE_COULDNT_READ_FILEE_LDAP_CANNOT_BINDE_LDAP_SEARCH_FAILEDE_LIBRARY_NOT_FOUNDE_FUNCTION_NOT_FOUNDE_ABORTED_BY_CALLBACKE_BAD_FUNCTION_ARGUMENTE_INTERFACE_FAILEDE_TOO_MANY_REDIRECTSE_UNKNOWN_OPTIONE_UNKNOWN_TELNET_OPTIONE_TELNET_OPTION_SYNTAXE_GOT_NOTHINGE_SEND_ERRORE_RECV_ERRORE_SHARE_IN_USEE_BAD_CONTENT_ENCODINGE_LDAP_INVALID_URLE_FILESIZE_EXCEEDEDE_FTP_SSL_FAILEDE_SEND_FAIL_REWINDE_LOGIN_DENIEDE_PEER_FAILED_VERIFICATIONE_TFTP_NOTFOUNDE_TFTP_PERME_TFTP_DISKFULLE_TFTP_ILLEGALE_TFTP_UNKNOWNIDE_TFTP_EXISTSE_TFTP_NOSUCHUSERE_CONV_FAILEDE_CONV_REQDE_REMOTE_FILE_NOT_FOUNDE_SSHE_FTP_PRET_FAILEDE_RTSP_CSEQ_ERRORE_RTSP_SESSION_ERRORE_CHUNK_FAILEDE_FTP_BAD_FILE_LISTE_FTP_ACCEPT_TIMEOUTE_NO_CONNECTION_AVAILABLEE_HTTP2PROXYTYPE_HTTPPROXYTYPE_HTTP_1_0PROXYTYPE_SOCKS4PROXYTYPE_SOCKS4APROXYTYPE_SOCKS5PROXYTYPE_SOCKS5_HOSTNAMEHTTPAUTH_ANYHTTPAUTH_ANYSAFEHTTPAUTH_BASICHTTPAUTH_DIGESTHTTPAUTH_DIGEST_IEHTTPAUTH_GSSNEGOTIATEHTTPAUTH_NEGOTIATEHTTPAUTH_NTLMHTTPAUTH_NTLM_WBHTTPAUTH_NONEHTTPAUTH_ONLYGSSAPI_DELEGATION_FLAGGSSAPI_DELEGATION_NONEGSSAPI_DELEGATION_POLICY_FLAGGSSAPI_DELEGATIONFTPSSL_NONEFTPSSL_TRYFTPSSL_CONTROLFTPSSL_ALLFTPAUTH_DEFAULTFTPAUTH_SSLFTPAUTH_TLSFORM_BUFFERFORM_BUFFERPTRFORM_CONTENTSFORM_FILEFORM_CONTENTTYPEFORM_FILENAMEFTPMETHOD_DEFAULTFTPMETHOD_MULTICWDFTPMETHOD_NOCWDFTPMETHOD_SINGLECWDCOOKIESESSIONDIRLISTONLYFTPPORTINFILEINFILESIZELOW_SPEED_LIMITLOW_SPEED_TIMEPROXYPASSWORDPROXYUSERNAMEPROXYUSERPWDREADFUNCTIONRESUME_FROMTELNETOPTIONSUSE_SSLUSERAGENTWRITEFUNCTIONOPT_RTSP_CLIENT_CSEQOPT_RTSP_REQUESTOPT_RTSP_SERVER_CSEQOPT_RTSP_SESSION_IDOPT_RTSP_STREAM_URIOPT_RTSP_TRANSPORTWRITEDATAREADDATAPROXYPORTHTTPPROXYTUNNELVERBOSENOPROGRESSNOBODYFAILONERRORFTPLISTONLYFTPAPPENDNETRCFOLLOWLOCATIONTRANSFERTEXTPUTPOSTFIELDSIZEHTTPHEADERPROXYHEADERHEADEROPTPATH_AS_ISPIPEWAITHTTPPOSTPROXY_SSLCERT_BLOBPROXY_SSLKEY_BLOBPROXY_ISSUERCERT_BLOBPROXY_CAINFO_BLOBSSLCERTPASSWDCRLFPOSTQUOTEPREQUOTEWRITEHEADERHEADERFUNCTIONSEEKFUNCTIONCOOKIEFILETIMECONDITIONTIMEVALUECUSTOMREQUESTSTDERRINTERFACEKRB4LEVELKRBLEVELPROGRESSFUNCTIONXFERINFOFUNCTIONFTP_USE_PRETLOGIN_OPTIONSSASL_IRXOAUTH2_BEAREROPT_FILETIMEMAXREDIRSMAXAGE_CONNFRESH_CONNECTFORBID_REUSERANDOM_FILEEGDSOCKETCONNECTTIMEOUTHTTPGETCOOKIEJARFTP_USE_EPSVSSLKEYPASSWDSSLENGINESSLENGINE_DEFAULTDNS_CACHE_TIMEOUTDNS_USE_GLOBAL_CACHEDEBUGFUNCTIONUPLOAD_BUFFERSIZENOSIGNALPROXYTYPEACCEPT_ENCODINGTRANSFER_ENCODINGHTTP200ALIASESUNRESTRICTED_AUTHFTP_USE_EPRTHTTPAUTHFTP_CREATE_MISSING_DIRSPROXYAUTHFTP_RESPONSE_TIMEOUTIPRESOLVEMAXFILESIZEINFILESIZE_LARGERESUME_FROM_LARGEMAXFILESIZE_LARGENETRC_FILEFTP_SSLPOSTFIELDSIZE_LARGETCP_NODELAYFTPSSLAUTHIOCTLFUNCTIONOPENSOCKETFUNCTIONCLOSESOCKETFUNCTIONSOCKOPTFUNCTIONFTP_ACCOUNTIGNORE_CONTENT_LENGTHOPT_COOKIELISTFTP_SKIP_PASV_IPFTP_FILEMETHODCONNECT_ONLYLOCALPORTLOCALPORTRANGEFTP_ALTERNATIVE_TO_USERMAX_SEND_SPEED_LARGEMAX_RECV_SPEED_LARGESSL_SESSIONID_CACHESSL_VERIFYSTATUSSSH_AUTH_TYPESSSH_PUBLIC_KEYFILESSH_PRIVATE_KEYFILESSH_KNOWNHOSTSSSH_KEYFUNCTIONFTP_SSL_CCCCONNECTTIMEOUT_MSACCEPTTIMEOUT_MSEXPECT_100_TIMEOUT_MSTCP_KEEPALIVETCP_KEEPIDLETCP_KEEPINTVLHTTP_TRANSFER_DECODINGHTTP_CONTENT_DECODINGNEW_FILE_PERMSNEW_DIRECTORY_PERMSPOST301PROXY_TRANSFER_MODEPROXY_SERVICE_NAMEPROXY_CAPATHPROXY_CAINFOPROXY_CRLFILEPRE_PROXYPROXY_SSLCERTPROXY_SSLCERTTYPEPROXY_SSLKEYPROXY_SSLKEYTYPEPROXY_KEYPASSWDPROXY_SSL_VERIFYPEERPROXY_SSL_VERIFYHOSTPROXY_PINNEDPUBLICKEYPROXY_SSLVERSIONPROXY_SSL_CIPHER_LISTPROXY_SSL_OPTIONSPROXY_TLSAUTH_TYPEPROXY_TLSAUTH_USERNAMEPROXY_TLSAUTH_PASSWORDPROXY_ISSUERCERTREQUEST_TARGETCOPYPOSTFIELDSSSH_HOST_PUBLIC_KEY_MD5AUTOREFERERADDRESS_SCOPEOPT_CERTINFOPOSTREDIRNOPROXYREDIR_PROTOCOLSPROTO_HTTPPROTO_HTTPSPROTO_FTPPROTO_FTPSPROTO_SCPPROTO_SFTPPROTO_TELNETPROTO_LDAPPROTO_LDAPSPROTO_DICTPROTO_FILEPROTO_TFTPPROTO_IMAPPROTO_IMAPSPROTO_POP3PROTO_POP3SPROTO_SMTPPROTO_SMTPSPROTO_RTSPPROTO_RTMPPROTO_RTMPTPROTO_RTMPEPROTO_RTMPTEPROTO_RTMPSPROTO_RTMPTSPROTO_GOPHERPROTO_SMBPROTO_SMBSPROTO_ALLTFTP_BLKSIZESOCKS5_GSSAPI_SERVICESOCKS5_GSSAPI_NECMAIL_FROMMAIL_RCPTMAIL_AUTHWILDCARDMATCHUNIX_SOCKET_PATHSSL_ENABLE_ALPNSSL_ENABLE_NPNSSL_FALSESTARTSSLOPT_ALLOW_BEASTSSLOPT_NO_REVOKEDEFAULT_PROTOCOLPROXY_TLS13_CIPHERSDOH_URLHTTP09_ALLOWEDAWS_SIGV4MAXLIFETIME_CONNM_TIMERFUNCTIONM_SOCKETFUNCTIONM_PIPELININGM_MAXCONNECTSM_MAX_HOST_CONNECTIONSM_MAX_TOTAL_CONNECTIONSM_MAX_PIPELINE_LENGTHM_CONTENT_LENGTH_PENALTY_SIZEM_CHUNK_LENGTH_PENALTY_SIZEM_PIPELINING_SITE_BLM_PIPELINING_SERVER_BLM_MAX_CONCURRENT_STREAMSPIPE_NOTHINGPIPE_HTTP1PIPE_MULTIPLEXIPRESOLVE_WHATEVERIPRESOLVE_V4IPRESOLVE_V6CURL_HTTP_VERSION_NONECURL_HTTP_VERSION_1_0CURL_HTTP_VERSION_1_1CURL_HTTP_VERSION_2_0CURL_HTTP_VERSION_2CURL_HTTP_VERSION_2TLSTCP_FASTOPENCURL_HTTP_VERSION_3CURL_HTTP_VERSION_LASTNETRC_OPTIONALNETRC_IGNOREDNETRC_REQUIREDSSLVERSION_DEFAULTSSLVERSION_SSLv2SSLVERSION_SSLv3SSLVERSION_TLSv1SSLVERSION_TLSv1_0SSLVERSION_TLSv1_1SSLVERSION_TLSv1_2SSLVERSION_TLSv1_3SSLVERSION_MAX_DEFAULTSSLVERSION_MAX_TLSv1_0SSLVERSION_MAX_TLSv1_1SSLVERSION_MAX_TLSv1_2SSLVERSION_MAX_TLSv1_3HAPROXYPROTOCOLTIMECONDITION_NONETIMECONDITION_IFMODSINCETIMECONDITION_IFUNMODSINCETIMECONDITION_LASTMODSSH_AUTH_ANYSSH_AUTH_NONESSH_AUTH_PUBLICKEYSSH_AUTH_PASSWORDSSH_AUTH_HOSTSSH_AUTH_KEYBOARDSSH_AUTH_DEFAULTSSH_AUTH_AGENTHEADER_UNIFIEDHEADER_SEPARATESOCKOPT_ALREADY_CONNECTEDSOCKOPT_ERRORSOCKOPT_OKKHTYPE_UNKNOWNKHTYPE_RSA1KHTYPE_RSAKHTYPE_DSSKHMATCH_OKKHMATCH_MISMATCHKHMATCH_MISSINGKHSTAT_FINE_ADD_TO_FILEKHSTAT_FINEKHSTAT_REJECTKHSTAT_DEFERSOCKTYPE_ACCEPTSOCKTYPE_IPCXNUSESSL_NONEUSESSL_TRYUSESSL_CONTROLUSESSL_ALLEFFECTIVE_URLHTTP_CODERESPONSE_CODETOTAL_TIMENAMELOOKUP_TIMEAPPCONNECT_TIMEPRETRANSFER_TIMESIZE_UPLOADSIZE_DOWNLOADSPEED_DOWNLOADSPEED_UPLOADHEADER_SIZEREQUEST_SIZESSL_VERIFYRESULTINFO_FILETIMECONTENT_LENGTH_DOWNLOADCONTENT_LENGTH_UPLOADSTARTTRANSFER_TIMECONTENT_TYPEREDIRECT_TIMEREDIRECT_COUNTREDIRECT_URLPRIMARY_IPPRIMARY_PORTLOCAL_IPLOCAL_PORTHTTP_CONNECTCODEHTTPAUTH_AVAILPROXYAUTH_AVAILOS_ERRNONUM_CONNECTSSSL_ENGINESINFO_COOKIELISTLASTSOCKETFTP_ENTRY_PATHINFO_CERTINFOCONDITION_UNMETINFO_RTSP_CLIENT_CSEQINFO_RTSP_CSEQ_RECVINFO_RTSP_SERVER_CSEQINFO_RTSP_SESSION_IDRTSPREQ_NONERTSPREQ_OPTIONSRTSPREQ_DESCRIBERTSPREQ_ANNOUNCERTSPREQ_SETUPRTSPREQ_PLAYRTSPREQ_PAUSERTSPREQ_TEARDOWNRTSPREQ_GET_PARAMETERRTSPREQ_SET_PARAMETERRTSPREQ_RECORDRTSPREQ_RECEIVERTSPREQ_LASTPAUSE_RECVPAUSE_SENDPAUSE_ALLPAUSE_CONTSEEKFUNC_OKSEEKFUNC_FAILSEEKFUNC_CANTSEEKDNS_SERVERSREDIR_POST_301REDIR_POST_302REDIR_POST_303REDIR_POST_ALLCONNECT_TOINFO_HTTP_VERSIONGLOBAL_SSLGLOBAL_WIN32GLOBAL_ALLGLOBAL_NOTHINGGLOBAL_DEFAULTGLOBAL_ACK_EINTRCSELECT_INCSELECT_OUTCSELECT_ERRSOCKET_TIMEOUTPOLL_NONEPOLL_INPOLL_OUTPOLL_INOUTPOLL_REMOVEVERSION_IPV6VERSION_KERBEROS4VERSION_KERBEROS5VERSION_SSLVERSION_LIBZVERSION_NTLMVERSION_GSSNEGOTIATEVERSION_DEBUGVERSION_CURLDEBUGVERSION_ASYNCHDNSVERSION_SPNEGOVERSION_LARGEFILEVERSION_IDNVERSION_SSPIVERSION_GSSAPIVERSION_CONVVERSION_TLSAUTH_SRPVERSION_NTLM_WBVERSION_HTTP2VERSION_UNIX_SOCKETSVERSION_PSLCURL_VERSION_HTTPS_PROXYCURL_VERSION_MULTI_SSLCURL_VERSION_BROTLICURL_VERSION_ALTSVCCURL_VERSION_HTTP3CURL_VERSION_UNICODECURL_VERSION_ZSTDCURL_VERSION_HSTSCURL_VERSION_GSASLE_CALL_MULTI_PERFORME_MULTI_CALL_MULTI_PERFORME_MULTI_OKE_MULTI_BAD_HANDLEE_MULTI_BAD_EASY_HANDLEE_MULTI_BAD_SOCKETE_MULTI_CALL_MULTI_SOCKETE_MULTI_OUT_OF_MEMORYE_MULTI_INTERNAL_ERRORE_MULTI_UNKNOWN_OPTIONE_MULTI_ADDED_ALREADYSH_SHARESH_UNSHARELOCK_DATA_COOKIELOCK_DATA_DNSLOCK_DATA_SSL_SESSIONLOCK_DATA_CONNECTLOCK_DATA_PSLioBytesIOStringIOcollectionsnamedtuplekey keytypeKhKeyssfamily socktype protocol addrCurlSockAddrcurl module init failedpycurlglobal_cleanupPyDict_GetItem(dict2, key) == ((void *)0)Curl_Type.tp_weaklistoffset > 0CurlMulti_Type.tp_weaklistoffset > 0CurlShare_Type.tp_weaklistoffset > 0pycurl: curl_version_info() failedpycurl: libcurl link-time version (%s) is older than compile-time version (%s)pycurl: libcurl link-time ssl backends (%s) do not include compile-time ssl backend (%s)CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGEinsobj2PyInit_pycurlCurlMulti objects do not support deserializationCurlMulti objects do not support serializationPyObject_IsInstance((PyObject *) self, (PyObject *) p_CurlMulti_Type) == 1self->multi_handle != ((void *)0)cannot add/remove handle - multi-stack is closedcannot add/remove handle - multi_perform() already runningcannot add/remove handle - perform() of curl object already runningcannot add/remove handle - curl object already on another multi-stackcannot invoke %s() - multi_perform() is currently runningmulti_socket_callback failed to acquire threadmulti_timer_callback failed to acquire threadcannot invoke %s() - no multi handleinitializing curl-multi failedcurl_multi_fdset() failed due to internal errorscurl object not on this multi-stackcurl_multi_remove_handle() failed due to internal errorscurl object already on this multi-stackobj->multi_stack == ((void *)0)curl_multi_add_handle() failed due to internal errorsargument to info_read must be greater than zeroUnable to fetch curl handle from curl objectPyObject_IsInstance((PyObject *) co, (PyObject *) p_Curl_Type) == 1unsetting is not supported for this optionlist/tuple items must be stringslists/tuples are not supported for this optioncallables are not supported for this optionsrc/multi.c(iiOO)timeouttimeout failedperform failedsocket_allii:socket_actionmulti_socket_action failediO:assignassign failedfdset(OOO)O!:remove_handleobj->multi_stack == selfO!:add_handlecurl object already closedd:selectinvalid timeout periodtimeout >= 0.0timeout < 1.0multi_fdset failed|i:info_readsurrogateescape(OiO)(iOO)pycurl.CurlMultido_multi_add_handledo_multi_info_readdo_multi_performdo_multi_socket_actiondo_multi_socket_alldo_multi_remove_handleassert_multi_statedo_multi_selectutil_multi_closedo_multi_new8~A?.Atrying to obtain a non-existing attribute: %Utrying to delete a non-existing attribute: %Usrc/pythoncompat.cPyListOrTuple_GetItemPyListOrTuple_SizeCurlShare objects do not support deserializationCurlShare objects do not support serializationinitializing curl-share failedPyObject_IsInstance((PyObject *) self, (PyObject *) p_CurlShare_Type) == 1src/share.cself->lock != ((void *)0)res == CURLE_OKpycurl.CurlShareassert_share_statedo_share_newsrc/stringcompat.cs != ((void *)0)replacePyType_HasFeature(Py_TYPE(((PyObject*)((obj)))), (1UL << 28))PyText_AsString_NoNULPyText_AsStringAndSizesrc/threadsupport.cself->handle != ((void *)0)locklock->locks[i] != ((void *)0)self->multi_stack->state == ((void *)0)self->multi_stack->multi_handle != ((void *)0)share_lock_destroypycurl_get_thread_state_multipycurl_get_thread_state;xLMM(P`P|QHQ(RRR,SPXXXHYYY$hZP8abc c<dXd(efff(jlHlmo hqL ht u w xT hy { X} X 8 x X (D h x @ d h  8ثXtȬHLX(x0Hxxx$DxhHh,`88h $X(&((*h.P5586 h6 646H7\87th7H99:;H;4;l;<=(> H>4>`?X@@@@@@,A@ATA8BHBXBzRx $IFJ w?;*3$"DH4\IBDD  GBF AABPL/AedL"D]|L"D](LAOJ  AAG 4 HM_BDD R ABA bREDpMPA{ L `MHf A b A 8pNBFA   ABA x ABA (RhADG m AAE SxAU x AA dShAa F (,S'BDD QDB(XSBDD \ ABG PTBBE A(F0 (A BBBJ A (A BBBH 8ZfBAA  ABK Z ABA <[AAG \ DAF ] AAI |AAT`\2App\EAc A $\kAv I _ A 0]AAD Q DAD vDAHl]BEE H(D0D8GP 8D0A(B BBBC 4^H^@\^BBB D(C0G@~ 0D(A BBBC 0dbnBDD F@  CABD (cnACG@ CAE @d BHE A(D0GP 0C(A BBBH 8DfBEG D(G@ (D ABBG HhBBH H(D0D8G` 8D0A(B BBBI 0jPBFF GP  CABF HkABHE E(D0D8GP 8D0A(B BBBB 8Ll BHD D(G@p (C ABBG 0mLBGF G0  CABF DnBEB A(D0G@O 0A(A BBBD HpBBE B(D0A8DP* 8A0A(B BBBH 8P4rBBA A(QP (D ABBG @uDBBB A(D0QP  0D(A BBBE w4Ah G C w4Ah G C<wBBD D(FW (A ABBA T0{Aa F y G x܁AQ  AH }BBB O(A0A8G 8A0A(B BBBA #GOBGBdTADdP nBGA D0y  AABE f  AABF w  AABE t AQ0q AD ,AQP AH , ؚBMA Q ABD 4 HADD0q AAD W AAG ($ KACD j DAI 8P BBA A(Q@ (A ABBD  xD [ A  DZ  AXP $TNBB A(D0 (A BBBF wD08D 0bBED G(D0i (A ABBA 0 dBKA D0  DABA \ Т]BBB B(A0A8GF\A 8A0A(B BBBI 4 @EBDD d GBI AABL X"D]d p"D],| BAA L ABA  Al A ( lADG { AAA ( &BDD PDB4 oBDA ` ABF lHEX LLAb E c x |Ap G I G 8 <BHD D(G@ (C ABBE ( AGG0 CAA 4~AAG w AAF  DAJ <8AG e AB 0`4BAA G0  AABK 0BAA G0  AABK 0 BAA Q@  AABB h Hh A H %AQ0x AA H@T BBB B(A0A8Gpx 8A0A(B BBBE 0BAA Q0  AABF 0BAA Q0  AABH @`BBB A(A0Q`~ 0A(A BBBA H8BBB B(A0N8Dp  8D0A(B BBBE LBBB B(A0A8Q 8D0A(B BBBC 0` sADG d AAF vCA4 ADG0T AAN P CAD @$!$T@!7^hl!7^|!!"D]!"D]!H H #Ae A $AQ0 AB  $,Aj(<%&BDD PDB4h %oBDA ` ABF lHED%4dO8l%ACG z DAF a AAE @&BDD G0d  AABG K  AABI 8&zD G E T'(h '[AMD o DAJ (@'#Qz E K A dC(D({Mb A C A dC($Ab($Ab$(8(L(`(t( 8(BFA t ABH D ABA ( )|BAA l DBF t) p) <h)AAF ] AAI d DAG JDApp2>MZ p (fG Gop01H  (IH" ooXHooFoG(GP(DgG U0!+80tEtR fWD Dm@I64CM<?>Q`;PBC0G@K83E3!0D^\8PZE ZGCC: (GNU) 4.4.7 20120313 (Red Hat 4.4.7-23)GCC: (conda-forge gcc 12.3.0-5) 12.3.0 0p# Gp% ip8 pN^Z G pG t" 0t" `t    & @< R h ~ Pf  2  0k  @ 0   &0 Ц 0K p^h l^ z   T H `b@Wh PW 3" 3" 3 & 4< 9 5P 6L_ 7<u 8 `; <h ` >  ?  (  PB% C  0GR $ @I 8 @K& H M @[ Qk^x   Z" PZ" H!  `\ 0! \ ^, ! !h # " "$@<2#EPR(G[^g(I9T}  9~ `U  0d"4BT8^e ^z { 5&Q@*A ?P_ Y7u  |z`^ p{h   P4$7Jx@X^o x"   Z$  @a1  p]?  Pe S v p^    ^4      P     0^+  p0< T g u       E  PY$  u    `|h =  P k  W}     v `]      |'/ B R _  }p  X^  (f  #     b{   )  ` : N [ r     6o       pe7H^K }] q (^ @u_  0L  D'6I ~Sj   d^  `^o   u(Y@ _Qx^Y ci y d p P ' 8J `t { `e  6 _  d| }%8 MZx  4 А    `a[ c$.> ИAPe~ 0^& Xs t s/"6GWj y @s9 Z c @  @3E! p2EX Kk y^ `n  C c1 C XO^P^o PA|  `z2H Xj  pc$ n @ Љ6 uPN {xg v@^ Y7   p n^ a#7 yAN Mb @}z Ph^V[crti.ocall_gmon_startcrtstuff.cderegister_tm_clones__do_global_dtors_auxcompleted.0__do_global_dtors_aux_fini_array_entryframe_dummy__frame_dummy_init_array_entryeasy.cdo_curl_setstatedo_curl_getstateutil_curl_init__PRETTY_FUNCTION__.4__PRETTY_FUNCTION__.5__PRETTY_FUNCTION__.3__PRETTY_FUNCTION__.8__PRETTY_FUNCTION__.7__PRETTY_FUNCTION__.6__PRETTY_FUNCTION__.2util_curl_close__PRETTY_FUNCTION__.1do_curl_close__PRETTY_FUNCTION__.0do_curl_reseteasycb.ckhkey_to_objectutil_write_callbackeasyinfo.cconvert_certinfo.part.0easyopt.cdo_curl_setopt_string_implutil_curl_unsetopteasyperform.cempty_tuple.1module.cPy_DECREFdo_curlmod_freeinsobj2insint_workercurlmodulecurl_methodsmulti.cdo_curlmulti_setstatedo_curlmulti_getstateutil_multi_close__PRETTY_FUNCTION__.9assert_multi_statecheck_multi_add_removedo_multi_closemulti_socket_callbackmulti_timer_callbackdo_multi_timeoutdo_multi_performdo_multi_socket_alldo_multi_socket_action__PRETTY_FUNCTION__.10do_multi_assigndo_multi_fdsetdo_multi_remove_handledo_multi_add_handledo_multi_selectdo_multi_info_readdo_multi_setoptempty_list.5pythoncompat.cshare.cdo_curlshare_setstatedo_curlshare_getstateassert_share_statedo_curlshare_setoptdo_share_closestringcompat.cthreadsupport.cutil.cdocstrings.c__FRAME_END____GNU_EH_FRAME_HDR__dso_handle_DYNAMIC__TMC_END___GLOBAL_OFFSET_TABLE_do_curl_performERR_peek_last_error@OPENSSL_3.0.0do_multi_dealloccurl_easy_performPyObject_Reprcurl_perform_rb_docseek_callbackshare_lock_newPyExc_ValueErrorcurl_multi_assignPyLong_AsLongcurl_easy_getinfop_CurlShare_Typecurlobject_constantsPyObject_CallBIO_new_mem_buf@OPENSSL_3.0.0PyExc_KeyError_Py_TrueStructmulti_timeout_doccurl_easy_reset_PyTrash_begincurl_share_initdo_multi_setattrocurlobject_methodsPyUnicode_DecodeLocalecurl_close_doccurl_easy_initPyListOrTuple_GetItemmulti_setopt_docPyEval_AcquireThreadmulti_socket_all_docPyObject_GetAttrStringcurl_share_setoptErrorObjectutil_curlslist_updatecurl_reset_docdo_curl_errstrPyMem_Freecurl_easy_strerrorstrchr@GLIBC_2.2.5curl_easy_duphandlePyType_IsSubtypePyModule_GetDictcurl_slist_appendPyThread_release_lockpycurl_module_docPyDict_SetItem__cxa_finalize@GLIBC_2.2.5strlen@GLIBC_2.2.5PyErr_WarnExPyErr_SetFromErrnodo_share_newPyText_CheckPyInit_pycurlshare_lock_callback_PyArg_ParseTupleAndKeywords_SizeTstringioPyTuple_NewPyObject_IsInstancedo_share_clearPyEval_RestoreThreadPyErr_NoMemory_Py_NoneStructPyExc_AttributeErrormulti_add_handle_docPyDict_SetItemStringkhkey_typeshare_setopt_docX509_free@OPENSSL_3.0.0memset@GLIBC_2.2.5PyList_AppendPyExc_MemoryErrorcurl_multi_setopt_PyTrash_condcurl_multi_add_handlePyType_Typedo_curl_clearPyListOrTuple_Checkdo_curl_newdo_global_cleanupassert_curl_stateX509_STORE_add_cert@OPENSSL_3.0.0do_curl_perform_rb__snprintf_chk@GLIBC_2.3.4curl_unsetopt_docPyList_SizePyTuple_SizePyErr_SetObjectdo_curl_duphandlecurlshareobject_methods_PyObject_Newcurl_version_info__assert_fail@GLIBC_2.2.5PyType_GenericAllocdo_curl_setattroPyBytes_FromStringPyFunction_TypePyErr_Formatcheck_curl_statePyFloat_FromDoublep_Curl_Type_finimulti_close_doccurl_multi_fdsetcurl_share_cleanupcurl_easy_pausepycurl_get_thread_state_multi_Py_DeallocPyCFunction_Type_Py_BuildValue_SizeTcurl_getinfo_docPyExc_OverflowErrorPyMem_MallocPyErr_ExceptionMatchesdo_curl_deallocPyList_NewPyImport_ImportModuledo_multi_getattromulti_select_doc_PyObject_CallMethod_SizeTPyUnicode_FromStringdebug_callbackcurl_multi_socket_allcreate_and_set_error_objectp_CurlHttppost_Typeutil_curl_xdecrefopensocket_callbackPyList_GetItemdo_version_infocurl_sockaddr_typedo_curl_getattrocurl_duphandle_docioctl_callbackcurl_multi_initselect@GLIBC_2.2.5curl_easy_cleanupPyErr_Cleardo_curl_getinfoPyDict_DelItemcurl_multi_performmulti_docPyObject_HasAttrStringmulti_remove_handle_docshare_lock_lockempty_keywordsBIO_free@OPENSSL_3.0.0curl_errstr_docinet_ntop@GLIBC_2.2.5do_share_getattromulti_assign_docPyDict_GetItempycurl_version_info_doccurlmultiobject_methodsdo_share_deallocbytesiopycurl_ssl_initmulti_fdset_docshare_lock_unlockPyExc_RuntimeWarningcurl_multi_cleanup__stack_chk_fail@GLIBC_2.4PyDict_NewPyErr_SetStringcurl_multi_remove_handledo_curl_pausecurl_setopt_string_doccurl_perform_docPyThreadState_Getdo_curl_setopt_stringcurl_slist_free_allpycurl_global_cleanup_docshare_unlock_callbackdo_multi_clearPyText_AsStringAndSizecurl_pause_docshare_lock_destroycurl_formfreePyUnicode_FromEncodedObjectdo_curl_setoptPyGILState_Releasedo_curl_set_ca_certscurl_versionERR_clear_error@OPENSSL_3.0.0curl_errstr_raw_docdo_curl_errstr_rawcurl_formaddssh_key_cbssl_ctx_callbackread_callbackstderr@GLIBC_2.2.5PyText_FromString_Ignorepycurl_acquire_thread_multiPyObject_GC_DelPyExc_TypeErrorxferinfo_callbackcurl_multi_info_readcurl_multi_socket_actioncurl_easy_setoptPyType_ReadyPyEval_SaveThreaddo_share_setattromy_getattroPyMethod_Typeshare_docPyObject_ClearWeakRefsdo_curlslist_deallocPyLong_AsLongLongPyObject_GC_UnTrackcurl_global_initPyLong_FromLongPyErr_NewExceptiondo_global_initdup@GLIBC_2.2.5share_close_docdo_share_traversePyObject_IsTrue_PyArg_ParseTuple_SizeTpycurl_release_threadcurl_getinfo_raw_docPyModule_Create2do_multi_traversedo_curl_traversePyThread_free_lockcurl_multi_timeoutdo_curl_perform_rsPyUnicode_AsEncodedStringcurl_docPyErr_OccurredPyObject_GenericGetAttrcurlshareobject_constantsPyDict_Copyclosesocket_callback__fprintf_chk@GLIBC_2.3.4curl_perform_rs_docpycurl_ssl_cleanupmulti_perform_docmy_setattroPyList_SetItemp_CurlSlist_Typedo_multi_newmemcpy@GLIBC_2.2.5curl_global_cleanupcurl_global_sslset_PyTrash_endPyEval_ReleaseThread_ITM_deregisterTMCloneTablePyCallable_CheckPyText_AsString_NoNULPyThread_allocate_lockPyThread_acquire_lockheader_callbackPyExc_ImportErrorPEM_read_bio_X509@OPENSSL_3.0.0curl_setopt_docpycurl_acquire_threaddo_curl_setopt_filelikedo_curl_unsetoptSSL_CTX_get_cert_store@OPENSSL_3.0.0PyGILState_EnsureERR_reason_error_string@OPENSSL_3.0.0do_curlhttppost_deallocutil_curlhttppost_update__gmon_start__p_CurlMulti_TypePyErr_PrintPyListOrTuple_SizePyTuple_GetItemcurl_set_ca_certs_doc_ITM_registerTMCloneTabledo_curl_getinfo_rawsockopt_cbcurlmultiobject_constantspycurl_get_thread_statepycurl_global_init_docmulti_info_read_docmulti_socket_action_docprogress_callbackPyBytes_AsStringAndSizeg_pycurl_useragent.symtab.strtab.shstrtab.gnu.hash.dynsym.dynstr.gnu.version.gnu.version_r.rela.dyn.init.plt.plt.got.text.fini.rodata.eh_frame_hdr.eh_frame.init_array.fini_array.dynamic.data.bss.commentp opp% HH-01015oFF>BoXHXHQHH"[ppappf p po0p0pu(f(f {pp ##&&\GG G G(G(Gj(I(IPP ^^0^TX^ %n x/