def _fill(self, wtd):
#
# Obfuscated code ahead. We keep at least one byte in the pre_buffer,
# so we don't stumble over an orphaned RUNCHAR later on. If the
# last or second-last char is a RUNCHAR we keep more bytes.
#
self.pre_buffer = self.pre_buffer + self.ifp.read(wtd + 2)
if self.ifp.eof:
self.post_buffer = self.post_buffer + \
binascii.rledecode_hqx(self.pre_buffer)
self.pre_buffer = ''
return
lastrle = string.rfind(self.pre_buffer, RUNCHAR)
if lastrle > 0 and lastrle == len(self.pre_buffer) - 1:
# Last byte is an RLE, keep two bytes
mark = len(self.pre_buffer) - 2
elif lastrle > 0 and lastrle == len(self.pre_buffer) - 2:
# second-last byte is an RLE. Decode all.
mark = len(self.pre_buffer)
else:
mark = len(self.pre_buffer) - 1
self.post_buffer = self.post_buffer + \
binascii.rledecode_hqx(self.pre_buffer[:mark])
self.pre_buffer = self.pre_buffer[mark:]
def _fill(self, wtd):
self.pre_buffer = self.pre_buffer + self.ifp.read(wtd + 4)
if self.ifp.eof:
self.post_buffer = self.post_buffer + binascii.rledecode_hqx(self.pre_buffer)
self.pre_buffer = b""
return
#
# Obfuscated code ahead. We have to take care that we don't
# end up with an orphaned RUNCHAR later on. So, we keep a couple
# of bytes in the buffer, depending on what the end of
# the buffer looks like:
# '\220\0\220' - Keep 3 bytes: repeated \220 (escaped as \220\0)
# '?\220' - Keep 2 bytes: repeated something-else
# '\220\0' - Escaped \220: Keep 2 bytes.
# '?\220?' - Complete repeat sequence: decode all
# otherwise: keep 1 byte.
#
mark = len(self.pre_buffer)
if self.pre_buffer[-3:] == RUNCHAR + b"\0" + RUNCHAR:
mark = mark - 3
elif self.pre_buffer[-1:] == RUNCHAR:
mark = mark - 2
elif self.pre_buffer[-2:] == RUNCHAR + b"\0":
mark = mark - 2
elif self.pre_buffer[-2:-1] == RUNCHAR:
pass # Decode all
else:
mark = mark - 1
self.post_buffer = self.post_buffer + binascii.rledecode_hqx(self.pre_buffer[:mark])
self.pre_buffer = self.pre_buffer[mark:]
def _fill(self, wtd):
self.pre_buffer = self.pre_buffer + self.ifp.read(wtd + 4)
if self.ifp.eof:
self.post_buffer = self.post_buffer + \
binascii.rledecode_hqx(self.pre_buffer)
self.pre_buffer = ''
return
#
# Obfuscated code ahead. We have to take care that we don't
# end up with an orphaned RUNCHAR later on. So, we keep a couple
# of bytes in the buffer, depending on what the end of
# the buffer looks like:
# '\220\0\220' - Keep 3 bytes: repeated \220 (escaped as \220\0)
# '?\220' - Keep 2 bytes: repeated something-else
# '\220\0' - Escaped \220: Keep 2 bytes.
# '?\220?' - Complete repeat sequence: decode all
# otherwise: keep 1 byte.
#
mark = len(self.pre_buffer)
if self.pre_buffer[-3:] == RUNCHAR + '\0' + RUNCHAR:
mark = mark - 3
elif self.pre_buffer[-1] == RUNCHAR:
mark = mark - 2
elif self.pre_buffer[-2:] == RUNCHAR + '\0':
mark = mark - 2
elif self.pre_buffer[-2] == RUNCHAR:
pass # Decode all
else:
mark = mark - 1
self.post_buffer = self.post_buffer + \
binascii.rledecode_hqx(self.pre_buffer[:mark])
self.pre_buffer = self.pre_buffer[mark:]
def _fill(self, wtd): # # Obfuscated code ahead. We keep at least one byte in the pre_buffer, # so we don't stumble over an orphaned RUNCHAR later on. If the # last or second-last char is a RUNCHAR we keep more bytes. # self.pre_buffer = self.pre_buffer + self.ifp.read(wtd+2) if self.ifp.eof: self.post_buffer = self.post_buffer + \ binascii.rledecode_hqx(self.pre_buffer) self.pre_buffer = '' return lastrle = string.rfind(self.pre_buffer, RUNCHAR) if lastrle > 0 and lastrle == len(self.pre_buffer)-1: # Last byte is an RLE, keep two bytes mark = len(self.pre_buffer)-2 elif lastrle > 0 and lastrle == len(self.pre_buffer)-2: # second-last byte is an RLE. Decode all. mark = len(self.pre_buffer) else: mark = len(self.pre_buffer)-1 self.post_buffer = self.post_buffer + \ binascii.rledecode_hqx(self.pre_buffer[:mark]) self.pre_buffer = self.pre_buffer[mark:]
def _load_logo():
_ds9_python_logo_text = r"""8dP08%a&)#!p)*!89##3-N**9&"*@#!J25#3&$JJN$*139K*8b!J)$dJN"3b)*!b6N&B59-a)#!p)*!5-cFi)*!b6N&B59-b)#!p)*!5-6B`)*!b3PT&8NmJ)#!p)*!0-#i`N!BJN$*#8d0"6%8J)$dJN!da,M#3"L#3-N4"9%&058iJ25#3$6!Z-*!')*!b4%&838e"@#!p)*!,-M8e,M#3"L#3JNK*8e428PNJ9%K*8b"'5946)%C*6%8J9d&6)%G&6N95394&4#"#@5"(58e3)&9658j()%C*9&059b#3Cd0268e&6P3J4QPdFe*A)'Pc)#K$+5"3CA4PFL",DA*MD'GPFh0ZCA)J+("PG'9b3'YTFQ0SCf9cFfjPFLjZCA3T,#"LGA3JBACKD@aKBQaP3dp068919#"eEQ4PFL"dD'8J4dj9)'GPEQ9bB@`JF(9LE'PM)'aTBf9ZBf8Z)*!M3dp068919#"'Eh)JFfpeFQ0PFb"cC@8JD(4dF$S[,hGhGbjVDA*MD'GPFh0ZCA)ZEQ9d)*"Y3dp068919#"*E@&RC5"dHA"P)(GTG'KTEL"(58e31L"(58e3Ae*(3Pp*68&(45#3)N0268e&6P3J8f9aG@9ZBf8JCQpb)%j"@%P6-b!J)$SJ8N9%,#"(8N9&6L`J3Na945#3F%914##3rb#3rb#3rb#3rb#3rb#38[q3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq30raj-B[krj$rrj"fq8dq9l,rN2rrN(INkZaRmIq3&IMSrj!4k2[rN!Iilqk3#1hmrj$rrj!mC-[rN"A3@Iq3$IVVrreTb2q3"[0RBR0cFh"F2$Be00ErN2rrN#l8YlCrHAUVm2q3"NClrj!9`acrN!frD[[k@T,rN!E)+0,lN!6kpH$9hrcrN2rrN#kU%4qXfm)k6GlrN!6J%c,`rj!8a!crN!fb2IAk@B,rN!AqXb26rrr!QIq3rrq30+S!DIcrrlF1E2lrrrk5#8Qjrj!*rHfpTlRNqrq3"-B*rrrrll([rj!&pr'c,I2j@(rrN!@p2c2Crrq@5[q3rrq30+S#M[rrrrFI(qVrrr3q-V9jrj!)rUXiF*5!3hVYrrrrb!MrN!5SBH$rrrriBAkd+I,j@(lrN!Afj2Mrrrq10[q3rrq30+S$N[q3"$F6b[rraJ0qm@$arj!(U5r'rIrqmeY9mIrrb`MrN!6pTMR3rZG950ke+2,j9hlrrrrqelM8m[hrrimdrj!%r[Rmrj$rrj!YUJ15rj!%14,&rrYT"p6rQDArN!Eq1RRqrj!%bbDjrrr1"rq3"IQ5-,CdNH[rYL6Ij9"prrrr[NNj6PjPD'G22@9H8dBj0Q[qrj$rrj!XUJ+2rrrrq53AeIrE*8,frq09p2q3"IS@SIq3"H)QS[rrc`IrN!EjA#r$rrrrYa"SDbCprrrrl0l0iHlcp*!%mqRA`DUZdIq3rrq3,DS!B2[rrli1-[MrP3@8r[rl5-hrN!BhE[q3"F3N[Irrc`ErN!IL)C6rrrqi*[,k@AcrN!6qd(KNT[(rN!6pcRjRmrq3rrq3,US"0)klVLS1TIh6,`bjqrlVAeRKrj!&XbQJr2rqhdKRp[rrc`ErN!KL-[hrrlNQm[TCI2q3"[V6DM#1jHHP4La'VrcrN2rrN#kU!ih"F$j)U[IeJ'0MJH[kUfjRQ[q3"IUf8@CeF9D4lIrrrmi&rj!%qVjaU$Y*Y,MeZLAbqPPlrj!)pVN`,9HC`pR`rj$rrj!`UJ15rrrprj!9q-iVFqrrN!A*"Iq3"1Z3!)b@NA**@HDP'r$k@AVrN!Ejp2IkebSXl2clqrlrN2rrN#qU!j,rN"RiZHrrN!DU![MrN!Z0+9lfmNPVrIq3"0G&'6eHEMBKB@0JAEhrN2rrN#qH!j,rN#'R1NVerj!,lZ[hkQBcS2hrN!6bi1MTN!6Pbk'&K0IrN2rrN#kU44LBrj!KiGVcrj!2ppMLrIq3rrq332cPbq(rN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN*MhdE+MS+rBqrq3rrq3FH+3!$`D#`-"#4jNf[q3rrq3E[Uh,3-!N!F"-H6rN2rrN'cjL`S!N!YAp2q3rrq3D[f'#J!!!bNf"J#3"JE!rj$rrj"TrVF6!!!+C0cSN4-!N!CVr[q3rrq3D2!Y!!!-QrArrrb*!`#3"6MZrj$rrj"RqRF!!"kmrj!&ldN!N!8Ie2q3rrq3Cm)6!#Hrr[q3"V!!N!82a2q3rrq3C[01!#(!r[q3"qX!N!8'Zrq3rrq3CUF+)XVqrj!)l`#3"3'frj$rrj"Pm8G`jrq3#Zm!N!8"Y[q3rrq3CIRNqIq3#qm!N!8#Yrq3rrq3Fqm!N!8&Z[q3ir(*TBYrIBLNbrIrN)A[!*!&#VrrN0rjcBj&%3F%!J%!!33)'@+mp[q3G[A2XCjY-aB9-RE-qqm!N!84a[q3#I$+cH,krj"!p0IFl2hrN!r0SE[rN&hedTYN3c53#68k5@LKhrq3#E%C!`#3$"&8b2lrN%chd1$frj!Ll*Jp'JN"!*!''''h!*!&'FrrN!MC3KFC*%#Kr2q3%2crlDpC3E$lrj!1rE9'0%23rj!2m-Z"0"iK+MeYU0Ihrj!,I3%8f2q3'Ih!lrq3'IH9h2Iqrj!JrFjD&J#3%!%hfIq3#+%!N"!DSrRrN%[Y15P9V2IrN"lqf%8$!*!-$`#3"56Drj!(pdN"!*!%&plrN"#CJ$i(!!!Berq3$ZJh!!!)Vrq3$2VIN!"$%3#3"`)E@,Rdrj!*JJ!'`rq3'FCCpIq3'PJ+3(k[f[crN"cjPJX!N"-#S2q3#+%!N"%'L[MrN%ZB"3!!60VrN"h2*`#3&$,Rrj!(X!#3"KMVrj!3FJ#3"ScrN!l@(J!!!*6rN!VpaPS0!*!0!d#irj!)J3!(hIq3'28k@2q3'p3K!!%)%#0DNVhJrIq3&[Cq"`#3&CRrN!LK!!%B6iQkfZAHa)p-%3#3"3U-rIq35ZBA!!!"-pArN"[T1`#3&86irj!'p93!N!C4r[q3%*8!N!CGrj!1e"X!!!##rj!*h'`0!3#3%!Yhl[q3"RX!#1[rN"IlL!&`rj!ErQN!N!B"$LK0J,(Dl[hrN"$pNJ`!N!F+)NGhRE5e8!#3"jcrN!LP+),5p[q3"r2"433!N!39YIq35d)!!!!"8IIrN"U""3#3&@6rN!I5&`#3"3LTrj!4V`#3"NrrN!l$#J!!!(IrN!IlX$%#!*!'$$%M!3#3#34Kl2q3"A%!"XrrN"I)'J#%rj!FX`)!N!S"%d"i`rVqrj!0b4F!N!B2AUcNr[q3"0F2!*!&!ClrN!MMiIq3$2"K"!#3"#Mbrj"+H!#3"!Zarj!Ck48!N"D5rj!(K3#3"LRJrj!4a!#3"NRrN!k3!!#3"(crN!EiN3`!N!B$3Dhad$)"!*!*"(Mqrj!%C3!%UIq3&[*0!!#@rj!Ff4i!!53*!*!+!5H(hIq3#rBf!*!'*F[rN!Ma33#3"35Prj!Ap&i!N!9qqrq35D!!N!91qrq3&rf$!3#3&32-rj!'k5i!N!C+rIq3%G%,!*!&4rq3$ISp!*!%K[q3"I&`!3#3"L#Uq[rrrq44!*!+%-ArN!4A!!&pr[q3&BN&!!#Srj!FkcX!!#D8-`-!N!S$(RcRrj!)rCJ#!*!%!cM3r[q3#2PH!*!&#V$rN"ME+J#3""[Crj!Rj2crN##i#3#3"!hZrj!Akbm!N!F',dBr%3#3#LVTrj!'TJN!N!CYrj!5fK`!N!9&rj!0a"-!N!53!2q3"2CZ"J#3"301eIlrN!AVEJF!N!J"E2hrrrp*!!"@prq3&0)@!!!!Z2q3(2K3!!!$C1+#(`)!N!S"2-,mrj!'j$%!!!!(,SVLrj!+r@d!N!86`rq3'2f6!*!&KIlrN#DCp[q3)-)4!*!&arq3&lX$!*!'%CMNq[5k03%!N!KPq[q3"Ie+!*!(NIq3%Z3Z!*!&3[[rN!aS!3!!!!+JrrrrrT!!#3#3"3*EjIq3#2D%%!#3##hkrrrr23!!,ZhrN"2d9!%!!!$'rj!G@J!!!!E"rpKV"J#3#aQZrj!'S!%!!"+4mrq3$2jb!*!&(YVrN"RZ&`#3"$6Vrj!Pp%IXrj!Jb"8!N!@Zrj!AE!#3"JQ9rj!&ebd!N!F#V2q3"YJ0!*!(Y[q3%["%!*!&12$rN![X$`#3"!UcrrrreJd!N!8"4ZrrN!VmP3X!N!F,q2rrrc%!!!A5rj!6V3-!N!6Arj!G@J#3"%(`rrl6AJd!N!S4Z[q3"23q!!!-U2lrN!hjA3#3"66jrj!Cr@`!N!3-ZIq3*EBIhrq3)-`C!*!&ZIq3&ZNe!*!'3IMrN!E!#`#3"Jlcrj!'M`-!N!B%e[q3%[jN!*!&)GErN!VqL3%!N!3@b2rrmNi!N!BMirq3$2bF"!#3"J,irrrr+!!!!(hrN",P-`#3"!MNrj!G@J#3"!@crrrrpF*4#J#3#5hYrrrrb4F!!%rcrj!1eaX!N!9Rrj!EV3N!N!4qrj!NrAJ&eIq3)-mE!*!%$16rN"E+&!#3"3+Drj!(q'3"!*!&6rq3"[PE!*!(%plrN"1#!*!&"UMrN!VV03#3"5,Grrqq#3#3"3HArj!1pfN$!*!&"rMrrrmP!!!!-q6rN"'9"!#3""lUrj!G@J#3"96irj!%pTSJ!3#3#*Iqrrqa"J!(Z[q3$Z98!*!&!UhrN!rmmqcSjqMZprq3"0m@!*!%3Iq3*2""!p6rN#$3(!!!!!*YrIq3&U8#!*!&)p[rN!M2#`#3"!5Arj!'mcX!N!FSj[q3%jm!N!C0qrq3#EB%!*!&0rMrrQF!N!BZj[q3$q)H!*!&%rRrrrmU!!!!"U2rN"$[0!#3"6Varj!G@J#3"4c5rj!'e8F!N!K%m2rrX!8#G[IrN!h+2J%!N!8QhIq3$ILlFciG#3)-*P5Gm[rrrL`!N!3Dmrq3)pi2#YIrN#$4(3!!!"cMrj!AF!#3"QAlrj!*53#3""M2rj!'m#F!N!G'mIq3%ld!N!B,XIq3#2TA!*!'C2rrk#m!N!CZrj!4FJ#3"56jrrrr1!#3"$[hrj!2V`X!N!9HqIq3(@%!N!8"S2q3"r"*!3#3"KRDrrq`(j2krj!,p,pR#J%!N!CbrIq3#rZX0!F"!*!("#HMq2pA!*!%%G(rN#1P!"2Erj!JdKd!!!"1rj!B23#3"3,%rj!+S!B!!!!`prq3"[!U!*!(F[hrN"2D!*!((pVrN!I1'J#3"TcrrmN@!*!'U[q3%D-!N!8rqrrrrdm!N!3,V[q3$e8!N!8#N!$rN"jb!*!'DIq3#0FE!*!'"-rrrpc+r2q3#IVFQ$i5!*!)$Y(rN![VG3d!N!`1GI9i!*!%#lIrN#,pB`!Hi2q3)0-H!!!!0pler2q3&1mJ!*!&1I2rN!VD)!!!!'(rN!Id2J#3"llrN"6`"3#3"d,Drj!'J!%!N!84c[rrY`J!N!E'rj!4R3#3"@(prrrrE`#3"8Vprj!0jJi!N!8)c[q3(S)!N!C"rj!*C`#3"mRrN![ppEpP)`#3#J*Yq[q3#[&M!`#3$J1"M!#3"!DMrj!LkM3!+qArN#$8(`!!!!)Q5eKGN!9HC(53!-$Zqrq3#0!9!*!%"k$qrj!+r83!!!#Drj!(qQ%!N!B8q[q3&28C!*!)4YlrN!64(J#3"MlYrrq[!3#3"XMrN"&d!*!%!BMrN!59!3#3"!66rj!-rBX"!*!&,2[rN"k4!*!'+rq3#D8"!*!'cIq3#H#RF5d"!*!-,ZMrN!Y`"!#3"KY4F(KS33N!!!!&83#3"!18rj!LaK%!+Ufm[X$%bpcfrj!Ce5!!N"%9CYRrN!H`#`#3"%hkrj!-IJ!!%XhrN!L8!`#3"8ErN"Ah-3#3#6rerrl2+`#3"hcrrrqa!`#3"V6rN"$e+J#3"!bhrj!%[3m!N!9PqIq3#q8P!*!&"TArN"qI!*!')rq3#EX+!*!&"p(rN!ITH4-(!*!1*F6rN!Zk#`#3"4Q4j[Ipr[[cdeX*!!!%!*!%!BhrN"hPPe0$G'`"!!-+#``-$3i5'MpmaIErN"AA)3#3%J%ESIArN!@5!J!!!$ICrj!0Y3)!21crN!M5#`#3"8(rN"Aj4`#3#30AM9S8!*!("p2rrrql#`#3"S,rN!rpPJF!N!3HkIq3"13T!*!&$m6rN!VkHJ%!N!8kl2q3(kS!N!BMrj!*`a%!N!85e[q3"Ibr333!N!i",llqrj!+mdJ!N!8NZrlrN!IcK3N!N!H*rj!Dqq'F-!3!!!!$!*!+!3SC3Dcmrj!8f#)!N"3-E1hrrrrqE3!!!#R(rj!1d4!!F[lrN!Ml*J#3"3c4rIq3%rYD!*!%'4X!N!i"6IMrrrr1'J#3"Mrbrj!0rFXD!*!&9rq3"IeE!*!'5HVrN!Qh&`#3"3ZXrj!JY3#3"L2rN!Qp$3#3"5(Hrj!%rC`9!*!1!3YLhIq3$-S&!*!%$+RrN!VeBJ#3"J',rj!BqmpY*J%!N!`#!aC-JUl6q2q3&YSN!*!%"*!'!`)"!*!)"((rrrrp43!!&-Iqrj!1h#-!`2rrrrllN!CL!*!'*Bh4mI[lr2hqrj!-r'X!N!4ET3N!N!d0[[q3"1Sa!*!'#k6rN!cq`LJ!N!8(V2q3"Ui#!*!&"@llrj!(e#N!N!CVp[q3),m!N!BMrj!*L3#3"METrrrrqT)"!*!0#d+)h[q3$R-!N!9LqIq3#qS9!*!&!T(rN"EVded&!*!)!`!!!"j(FkIEr2q3'p`Q!!!!%XhrN!6filb"1JF!N!F,errrr"F!(-2rN"$T1#[`rrrr``m!N"!#$#*$FD,9r[q3#Ijk!*!%GIbJ"`#3#`4irj!'D!#3"a+br2q3#HGc$3#3"MhYrj!'k6F!N!B%@q2rN!6iVKJ!N!BkmIq3)FF!N!BMrj!)rN8!N!C1pIrrrlN3!*!*##*!F+MCm2lrN!Mqrj!&m%!!N!3%`rq3$2eV!3#3"!@Erj!@q[ESeV5PUV5qap(DR3!!"F(brIq3(YdQ!!!!!@Vprj!'rZke43)!N!8$N[rriJ%GYIlrN"$a4R6mrrrrm9!!N"8(&N+Bf[hrN!H$!*!%LrrlN!!3!*!*"',Yrj!'`JS!N!F1ClcJp2[jmGZmG#)$!*!'#+hrN!IqR!#3"`)PEk5XL%!-!*!'-0MrN#,1!*!')rq3#0iA!*!'ErlrrrP0!*!'!K-mK,MApIq3$1$'rj!&fb3!N!3Pl[q3$Dd*!*!%#+VrN#+e!!!3fIq3)0iR!*!%%ZVrN!RZG!X!N!9Pq[q[&DVmrj!4p9E(rj!&cc!#!*!,"!#3#J-PF0Vkrj!&K3#3"+(rrrQK)`%!N!8"%AVYrj!(meN!N!N0+N"'4$`Q#`#3#9rdrj!)mM8!N")",mRrN#29!*!'*Iq3"rk4"!#3"U$rrrrB)J#3"3YXc2hrN!rd@CRrN!A-%J#3"&,hrj!0f"3!N!3-Zrq3)V8!!#(Krj!Jh5B!N!@Mrj!+qhN#!*!%426rVF$prj!5qBVprj!'jSTSA%mM!3#3"S4V,J-!N!S9GZ6rrrrqJ!#3",MrN!6CEaS!!!)RE-ErN!VI(3#3'#rVrj!+[Jm!N"%qe[q3*0X!N!BTrj!(pM-!N!B#h2rrrlX0!*!%(FIprj!4N`D(rj!&`JB!N!4Ur2q3$HmD!*!%%YIrN#+e!!"%m2q3)0SN!*!&N!$rN![Y4!#3"#[[rrlrN"6pl2q3#Ihpr29`!*!'erhlqC!-q[lrrrrqH`#3"-rrN!Apq16GlrVprj!-e8J'!*!8!NVJrj!,rTB-!*!1#'6crj!Ph`#3"M$rN!EqV!-!N!BPprrrrk)"!!!!$UlrN",Q)J"Srj!&[`%!N!4er[q3$ISF!*!%'r,rN#+e!!"Zr2q3)03I!*!&Trq3$*S!N!3El2q3*F3!N!EArj!6rA8!!!!,h2q3'HfV64d&!*!2!b5'k2q3$IH2%3#3#`-aS[ArN#EN!*!'22q3"ZNr!*!(Crcrrrq'!*!%22VrN"(mI`-!52q3"F!%!*!%FIhrN!he'`#3"$[rN#1e!!#jrj!Kc"N!N!A0rj!-dJ#3"!rTrj!Pc!#3"YIrN"2mC`!!!#$Nrj!EqY'UH8mZ'4H3#"mcACVErIq3$rUc+3B!N!F((SAJrj!Sj`#3"NhrN!AqL3)!N!B*V2q3"(!!N!4Xrj!5fK-!!$2rN!A($!#3"',krj!0jaJ!N!4`rj!MY3!Gprq3)F35!*!%$I2rN!cI!*!%"qMrN#A-!*!'erq3%rYA!!!!11crN%(`ReBN#J34-QDQlIq3+ZN!N!CRrj!&ZaF!N!FNl[q3"'-!N!4Jrj!4p&`!!!"*rj!&e4i!N!3mm[q3$F)1!!!!"UlrN#1e")Vqrj!KZ!J!N!4%qrq3$-3!N!3#jrq3*F`!N!EArj!6q8F!!!"9prq33rRcm1rapI[rN#cV!*!'KIq3"0XZ!*!("B[rN!9J!*!%+ZrrN!rfL`S!!!1)rj!&kMF!N!34iIq3$2k4"!!!!#6Crj!MY5MMrj!LU3%!!!!#K[lrN![qJJ#3"!,Rrj!Pc3%!N!3%fIq3%rF[!!!!HIlrN(EX!*!&!UhrrrrQ23%!N!Fjk2q3"AB!N!3(Q2q3$IlaF3X!!!!Jf2q3"IaL!*!&PIlrN![i2J#3"&Rlrj!Mb+MrN#13!!#3"!r#rj!-h#X!N!3-kIq3*G%*!*!%%prrN"2d&3!!!DVrN(IY!*!&'Flrrmif!*!)%EhrN!Di$3#3""29rj!,p+3X!*!%"jArN!Hf!*!&,H$rN!ZZ!3!!!!@jrj"*E!#3"#Ihrj!,hNF!N!8MlIq3*Hk-H*!%N!$crj!6k3%!!!,Rrj"hk`#3"8,aqD-L!3#3"`+9qrq3"[%p!*!&00,rN!Imfj3c#!#3"!0bp2q3"qie!*!%!Q$brj!*c5N!N!4*m2q358N!N!3mVT!*VCe`'`)!N!9*pIq33-)!!!!`r[q3GqB!N!3$NY9L#`#3#!CPqIq3#)8!N!BdZ2,mq1hGUPiP!J#3"3GXm2q3#2kM"`#3"!GKjIhrN!Aj[M8!N!3([rq35IiT!*!BE2crN%#B!!!"H2q3H0d!N!3QAaX!N!N$DI2rN!R#!`#3"JY*BeJp&3%!N!F(G2MrN!Vk8!#3"Lb%b[$jjVCN%!#3"!0Rrj"+laF!N"F%Q[q33@d!!!kkrj"icJ#3$`q-p[q3#ZBZ!*!6$jAmrj!-jN)!N"%"6[(rN%V5%!#3&bIYrj"!q&)!!$,erj"iZJ#3$33aZ[VrN![lK!#3%K#Mq[q3$YT1!J#3$J09i2q35lJ,!*!9#NA(rj""l6m!!SRrN(QK!*!+""-pPq,rN!l`4!)!N!m@R[hrN"$UG48#!*!+!4*kkrq36+)'!*!("3d8("q3"L3a5hHhl2q33Z)T!#RDrj"jK!#3##4EPG$mrj!4j9%#!*!0-VMrN"6-EK`!N!J@D-RrN%kH"3!!!!JeAS+IZpIcrj"1e"!#Q[q3HIjJ!!!"%d&[U1$jr2q3&IH[9#S6"`)%#"!I-Nef[rArN"EppmUDHfTTGj6$pIhrN%qH"4"5V1Vkr2lrN&+k!h(hrj"jq@BU9k2Al[hrN"[fj0R5d0(6eplRp2lrN(1P@-Aerj"AS'lbrj"lj16prj#Hjr2rN&RQq2q3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3M300"""
import binascii
_ds9_python_logo = binascii.a2b_hqx(
_ds9_python_logo_text.encode("ascii"))[0]
return binascii.rledecode_hqx(_ds9_python_logo)
def test_hqx(self):
# Perform binhex4 style RLE-compression
# Then calculate the hexbin4 binary-to-ASCII translation
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def test_hqx(self):
# Perform binhex4 style RLE-compression
# Then calculate the hexbin4 binary-to-ASCII translation
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def test_not_implemented(self):
test_cases = [
lambda: binascii.a2b_hqx(None),
lambda: binascii.rledecode_hqx(None),
lambda: binascii.rlecode_hqx(None),
lambda: binascii.b2a_hqx(None),
]
for temp_func in test_cases:
self.assertRaises(NotImplementedError, temp_func)
def _fill(self, wtd):
self.pre_buffer = self.pre_buffer + self.ifp.read(wtd + 4)
if self.ifp.eof:
self.post_buffer = self.post_buffer + binascii.rledecode_hqx(self.pre_buffer)
self.pre_buffer = ''
return
mark = len(self.pre_buffer)
if self.pre_buffer[-3:] == RUNCHAR + '\x00' + RUNCHAR:
mark = mark - 3
elif self.pre_buffer[-1] == RUNCHAR:
mark = mark - 2
elif self.pre_buffer[-2:] == RUNCHAR + '\x00':
mark = mark - 2
elif self.pre_buffer[-2] == RUNCHAR:
pass
else:
mark = mark - 1
self.post_buffer = self.post_buffer + binascii.rledecode_hqx(self.pre_buffer[:mark])
self.pre_buffer = self.pre_buffer[mark:]
def _fill(self, wtd):
self.pre_buffer = self.pre_buffer + self.ifp.read(wtd + 4)
if self.ifp.eof:
self.post_buffer = self.post_buffer + binascii.rledecode_hqx(self.pre_buffer)
self.pre_buffer = ''
return
mark = len(self.pre_buffer)
if self.pre_buffer[-3:] == RUNCHAR + '\x00' + RUNCHAR:
mark = mark - 3
elif self.pre_buffer[-1] == RUNCHAR:
mark = mark - 2
elif self.pre_buffer[-2:] == RUNCHAR + '\x00':
mark = mark - 2
elif self.pre_buffer[-2] == RUNCHAR:
pass
else:
mark = mark - 1
self.post_buffer = self.post_buffer + binascii.rledecode_hqx(self.pre_buffer[:mark])
self.pre_buffer = self.pre_buffer[mark:]
def test_deprecated_warnings(self):
with self.assertWarns(DeprecationWarning):
self.assertEqual(binascii.b2a_hqx(b'abc'), b'B@*M')
with self.assertWarns(DeprecationWarning):
self.assertEqual(binascii.a2b_hqx(b'B@*M'), (b'abc', 0))
with self.assertWarns(DeprecationWarning):
self.assertEqual(binascii.rlecode_hqx(b'a' * 10), b'a\x90\n')
with self.assertWarns(DeprecationWarning):
self.assertEqual(binascii.rledecode_hqx(b'a\x90\n'), b'a' * 10)
def test_hqx(self):
# Perform binhex4 style RLE-compression
# Then calculate the hexbin4 binary-to-ASCII translation
if test_support.due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
return
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def test_hqx(self):
# Perform binhex4 style RLE-compression
# Then calculate the hexbin4 binary-to-ASCII translation
if test_support.due_to_ironpython_bug(
"http://ironpython.codeplex.com/workitem/28171"):
return
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def test_not_implemented():
test_cases = [
lambda: binascii.a2b_qp(None),
lambda: binascii.a2b_qp(None, None),
lambda: binascii.a2b_hqx(None),
lambda: binascii.rledecode_hqx(None),
lambda: binascii.rlecode_hqx(None),
lambda: binascii.b2a_hqx(None),
lambda: binascii.crc_hqx(None, None),
]
for temp_func in test_cases:
AssertError(NotImplementedError, temp_func)
def test_not_implemented(self):
test_cases = [
lambda: binascii.a2b_qp(None),
lambda: binascii.a2b_qp(None, None),
lambda: binascii.a2b_hqx(None),
lambda: binascii.rledecode_hqx(None),
lambda: binascii.rlecode_hqx(None),
lambda: binascii.b2a_hqx(None),
lambda: binascii.crc_hqx(None, None),
]
for temp_func in test_cases:
self.assertRaises(NotImplementedError, temp_func)
def test_rle(self):
# test repetition with a repetition longer than the limit of 255
data = (b'a' * 100 + b'b' + b'c' * 300)
encoded = binascii.rlecode_hqx(data)
self.assertEqual(encoded,
(b'a\x90d' # 'a' * 100
b'b' # 'b'
b'c\x90\xff' # 'c' * 255
b'c\x90-')) # 'c' * 45
decoded = binascii.rledecode_hqx(encoded)
self.assertEqual(decoded, data)
def test_rle(self):
# test repetition with a repetition longer than the limit of 255
data = (b'a' * 100 + b'b' + b'c' * 300)
encoded = binascii.rlecode_hqx(data)
self.assertEqual(encoded,
(b'a\x90d' # 'a' * 100
b'b' # 'b'
b'c\x90\xff' # 'c' * 255
b'c\x90-')) # 'c' * 45
decoded = binascii.rledecode_hqx(encoded)
self.assertEqual(decoded, data)
def recv_callback(msg):
t = time.time()
# print '\nReceived '+ str(t) + ': ' + str(msg.application_headers)
# print '\t' + str(msg.body) + '\n'
headers = msg.application_headers
print("#################################\n")
print("Received " + str(t) + ": " + str(headers["name"]))
print(headers["time"])
(type, pkt) = unstuffPkt(headers["name"], float(headers["time"]), msg.body,
int(headers["nbytes"]))
print("srcname: " + str(pkt.srcname()) + "\n")
print("time: " + str(pkt.time()) + "\n")
print("PktType: " + str(pkt.PacketType()) + "\n")
print("type: " + str(pkt.type()) + "\n")
print("nchannels: " + str(pkt.nchannels()) + "\n")
print("pf: " + str(pkt.pf()) + "\n")
print("string: " + str(pkt.string()) + "\n")
print("db: " + str(pkt.db()) + "\n")
print("dfile: " + str(pkt.dfile()) + "\n")
print("version: " + str(pkt.version()) + "\n")
pktchannel = pkt.channels(0)
print("time: " + str(pktchannel.time()) + "\n")
print("net: " + str(pktchannel.net()) + "\n")
print("sta: " + str(pktchannel.sta()) + "\n")
print("chan: " + str(pktchannel.chan()) + "\n")
print("loc: " + str(pktchannel.loc()) + "\n")
print("nsamp: " + str(pktchannel.nsamp()) + "\n")
print("samprate: " + str(pktchannel.samprate()) + "\n")
print("data: " + str(pktchannel.data()) + "\n")
print("calib: " + str(pktchannel.calib()) + "\n")
print("calper: " + str(pktchannel.calper()) + "\n")
print("segtype: " + str(pktchannel.segtype()) + "\n")
print("##")
print("## Start binascii test")
print("##")
rle = binascii.rledecode_hqx(msg.body)
print(rle)
print("##")
print("##")
def recv_callback(msg):
t = time.time()
#print '\nReceived '+ str(t) + ': ' + str(msg.application_headers)
#print '\t' + str(msg.body) + '\n'
headers = msg.application_headers
print '#################################\n'
print 'Received '+ str(t) + ': ' + str(headers['name'])
print headers['time']
(type,pkt) = unstuffPkt( headers['name'], float(headers['time']), msg.body, int(headers['nbytes']) )
print 'srcname: ' + str(pkt.srcname()) + '\n'
print 'time: ' + str(pkt.time()) + '\n'
print 'PktType: ' + str(pkt.PacketType()) + '\n'
print 'type: ' + str(pkt.type()) + '\n'
print 'nchannels: ' + str(pkt.nchannels()) + '\n'
print 'pf: ' + str(pkt.pf()) + '\n'
print 'string: ' + str(pkt.string()) + '\n'
print 'db: ' + str(pkt.db()) + '\n'
print 'dfile: ' + str(pkt.dfile()) + '\n'
print 'version: ' + str(pkt.version()) + '\n'
pktchannel = pkt.channels(0)
print 'time: ' + str(pktchannel.time()) + '\n'
print 'net: ' + str(pktchannel.net()) + '\n'
print 'sta: ' + str(pktchannel.sta()) + '\n'
print 'chan: ' + str(pktchannel.chan()) + '\n'
print 'loc: ' + str(pktchannel.loc()) + '\n'
print 'nsamp: ' + str(pktchannel.nsamp()) + '\n'
print 'samprate: ' + str(pktchannel.samprate()) + '\n'
print 'data: ' + str(pktchannel.data()) + '\n'
print 'calib: ' + str(pktchannel.calib()) + '\n'
print 'calper: ' + str(pktchannel.calper()) + '\n'
print 'segtype: ' + str(pktchannel.segtype()) + '\n'
print '##'
print '## Start binascii test'
print '##'
rle = binascii.rledecode_hqx(msg.body)
print rle
print '##'
print '##'
a2b = binascii.a2b_hex(b2a) print repr(a2b) b2a = binascii.b2a_hqx(str) print repr(b2a) a2b,done = binascii.a2b_hqx(b2a) # returns a string instead of a tuple print repr(a2b),done b2a = binascii.b2a_base64(str) print repr(b2a) a2b = binascii.a2b_base64(b2a) print repr(a2b) b2a = binascii.rlecode_hqx(str) print repr(b2a) a2b = binascii.rledecode_hqx(b2a) print repr(a2b) b2a = binascii.hexlify(str) print repr(b2a) a2b = binascii.unhexlify(b2a) print repr(a2b) # delslice bug all = range(10) print all[2:8:2] all[1:3] = range(5) print all del all[1:7:2] print all
def decode_file(data_input, nome_arq): dataoutput = binascii.rledecode_hqx(output_file(data_input, nome_arq)) return str(dataoutput)
def test_hqx(self):
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def test_rle(self):
data = b'a' * 100 + b'b' + b'c' * 300
encoded = binascii.rlecode_hqx(data)
self.assertEqual(encoded, b'a\x90dbc\x90\xffc\x90-')
decoded = binascii.rledecode_hqx(encoded)
self.assertEqual(decoded, data)
"""Macintosh binhex compression/decompression.
#!/usr/bin/python
import socket
import binascii
def input_file(nome_arq):
with open(nome_arq, "rb") as f:
byte = f.read()
return byte
def output_file(out_info, out_name):
nome_cypt = str(out_name[0:-3]) + "dec"
arq_out = open(nome_cypt, "wb+")
arq_out.write(out_info)
arq_out.close()
datainput = binascii.rlecode_hqx(input_file('FF.txt'))
#print(datainput)
output_file( datainput, 'FF.txt')
dataoutput = binascii.rledecode_hqx(datainput)
output_file(dataoutput, "FFO.txt")
#print(dataoutput)
def decode_file(nome_arq): dataoutput = binascii.rledecode_hqx(output_file(nome_arq)) return dataoutput
def thg_encode(self, args):
"""modulo referente a encode de estrings"""
arg_mensage = args.split(" ")
if arg_mensage[0] == "":
print("""suporte encode:
Este módulo fornece funções para codificar dados binários em caracteres ASCII
imprimíveis e decodificar essas codificações de volta para dados binários.
Ele fornece funções de codificação e decodificação para as codificações
especificadas em RFC 3548 ,que define os algoritmos Base16, Base32 e Base64,
e para as codificações Ascii85 e Base85 padrão de fato.
a2b_uu
b2a_uu
a2b_base64
b2a_base64
a2b_qp
b2a_qp
a2b_hqx
rledecode_hqx
rlecode_hqx
b2a_hqx
crc_hqx
crc32
b2a_hex
a2b_hex
hexlify
unhexlify
Charcode
binary
base62
basen
bcd
ur
unicode_normalize
qp_encoding
encode type[2,16,32,64] str
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
elif arg_mensage[0] == "64":
arg_mensage[1] = arg_mensage[1].encode('ascii')
base64_bytes = base64.b64encode(arg_mensage[1])
by_to_st(base64_bytes)
elif arg_mensage[0] == "32":
arg_mensage[1] = arg_mensage[1].encode('ascii')
b32encode_bytes = base64.b32encode(arg_mensage[1])
by_to_st(b32encode_bytes)
elif arg_mensage[0] == "16":
arg_mensage[1] = arg_mensage[1].encode('ascii')
b16encode_bytes = base64.b16encode(arg_mensage[1])
by_to_st(b16encode_bytes)
elif arg_mensage[0] == "a85encode":
arg_mensage[1] = arg_mensage[1].encode('ascii')
a85encode_bytes = base64.a85encode(arg_mensage[1])
by_to_st(a85encode_bytes)
elif arg_mensage[0] == "b85encode":
arg_mensage[1] = arg_mensage[1].encode('ascii')
b85encode_bytes = base64.b85encode(arg_mensage[1])
by_to_st(b85encode_bytes)
elif arg_mensage[0] == "a2b_uu":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Converta uma única linha de dados uuencodificados de volta em binários e retorne os dados binários. As linhas normalmente contêm 45 bytes (binários), exceto a última linha. Os dados da linha podem ser seguidos de espaços em branco."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.a2b_uu(arg_mensage[1])))
elif arg_mensage[0] == "a2b_base64":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED}Converta dados binários em uma linha de caracteres ASCII na codificação base64. O valor de retorno é a linha convertida, incluindo um caractere de nova linha. O comprimento dos dados deve ser de no máximo 57 para aderir ao padrão base64."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.a2b_base64(arg_mensage[1]))
elif arg_mensage[0] == "b2a_base64":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Converta dados binários em uma linha de caracteres ASCII na codificação base64. O valor de retorno é a linha convertida, incluindo um caractere de nova linha. O comprimento dos dados deve ser de no máximo 57 para aderir ao padrão base64."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.b2a_base64(b'arg_mensage[1]'))
elif arg_mensage[0] == "a2b_qp":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED}Converta um bloco de dados imprimíveis entre aspas de volta em binários e retorne os dados binários. Mais de uma linha pode ser passada por vez. Se o cabeçalho do argumento opcional estiver presente e verdadeiro, os sublinhados serão decodificados como espaços."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.a2b_qp(arg_mensage[1]))
elif arg_mensage[0] == "b2a_qp":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED}Converta dados binários em uma (s) linha (s) de caracteres ASCII em codificação imprimível entre aspas. O valor de retorno é a (s) linha (s) convertida (s). Se o argumento opcional quotetabs estiver presente e verdadeiro, todas as tabulações e espaços serão codificados. Se o argumento opcional istext estiver presente e verdadeiro, as novas linhas não serão codificadas, mas os espaços em branco finais serão codificados. Se o cabeçalho do argumento opcional estiver presente e verdadeiro, os espaços serão codificados como sublinhados de acordo com RFC1522. Se o cabeçalho do argumento opcional estiver presente e for falso, os caracteres de nova linha também serão codificados; caso contrário, a conversão de alimentação de linha pode corromper o fluxo de dados binários."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.a2b_qp(arg_mensage[1].encode()))
elif arg_mensage[0] == "a2b_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED}Converta dados ASCII formatados de binhex4 em binários, sem fazer a descompressão RLE. A string deve conter um número completo de bytes binários ou (no caso da última parte dos dados binhex4) ter os bits restantes zero.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.a2b_hqx(arg_mensage[1]))
elif arg_mensage[0] == "rledecode_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Execute a descompressão RLE nos dados, de acordo com o padrão binhex4. O algoritmo usa 0x90 após um byte como um indicador de repetição, seguido por uma contagem. Uma contagem de 0 especifica um valor de byte de 0x90 . A rotina retorna os dados descompactados, a menos que os dados de entrada de dados terminem em um indicador de repetição órfão, caso em que a exceção Incompleta é levantada."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.rledecode_hqx(arg_mensage[1].encode())))
elif arg_mensage[0] == "rlecode_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Execute a compactação RLE no estilo binhex4 nos dados e retorne o resultado."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.rlecode_hqx(arg_mensage[1].encode())))
elif arg_mensage[0] == "b2a_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Execute a conversão hexbin4 binário para ASCII e retorne a string resultante. O argumento já deve ser codificado por RLE e ter um comprimento divisível por 3 (exceto possivelmente o último fragmento).
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.b2a_hqx(arg_mensage[1].encode())))
elif arg_mensage[0] == "crc_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Calcule o valor binhex4 crc dos dados , começando com um crc inicial e retornando o resultado.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.crc_hqx(arg_mensage[1].encode(),
int(arg_mensage[2]))))
elif arg_mensage[0] == "crc32":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Calcule CRC-32, a soma de verificação de dados de
32 bits, começando com um crc inicial. Isso é consistente com a soma de verificação do arquivo ZIP.
Uma vez que o algoritmo é projetado para uso como um algoritmo de soma de verificação, não é adequado
para uso como um algoritmo de hash geral.
{YELLOW}Nota{YELLOW}{RED} Para gerar o mesmo valor numérico em todas as versões e plataformas Python, {RED}{BLUE}use crc32 (dados) & 0xffffffff{BLUE}{RED}. Se você estiver usando apenas a soma de verificação no formato binário compactado, isso não é necessário, pois o valor de retorno é a representação binária correta de 32 bits, independentemente do sinal.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.crc32(arg_mensage[1].encode())))
elif arg_mensage[0] == "hexlify":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Retorna a representação hexadecimal dos dados
binários . Cada byte de dados é convertido na representação hexadecimal de 2 dígitos correspondente.
A string resultante é, portanto, o dobro do comprimento dos dados .
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.hexlify(arg_mensage[1].encode(),
arg_mensage[2].encode())))
elif arg_mensage[0] == "b2a_hex":
if arg_mensage[1] == "help":
print("""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} hex
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.b2a_hex(arg_mensage[1].encode(),
int(arg_mensage[2]))))
elif arg_mensage[0] == "unhexlify":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Retorna os dados binários representados pela string hexadecimal hexstr . Esta função é o inverso de b2a_hex () . hexstr deve conter um número par de dígitos hexadecimais (que podem ser maiúsculas ou minúsculas), caso contrário, um TypeError é gerado.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.unhexlify(arg_mensage[1].encode())))
elif arg_mensage[0] == "b2a_uu":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Converta dados binários em uma linha de caracteres ASCII, o valor de retorno é a linha convertida, incluindo um caractere de nova linha. O comprimento dos dados deve ser de no máximo 45.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.b2a_uu(arg_mensage[1].encode(),
int(arg_mensage[2]))))
elif arg_mensage[0] == "charcode":
if arg_mensage[1] == "help":
print(
"""{YELLOW}charcode{YELLOW}{BLUE} =>{BLUE}{RED}converte string em charcode
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(ord(arg_mensage[1].encode()))
elif arg_mensage[0] == "binary":
if arg_mensage[1] == "help":
print(
"""{YELLOW}binary{YELLOW}{BLUE} =>{BLUE}{RED}converte string em binary
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(' '.join(format(ord(x), 'b') for x in arg_mensage[1]))
elif arg_mensage[0] == "base62":
if arg_mensage[1] == "help":
print(
"""{YELLOW}base62{YELLOW}{BLUE} =>{BLUE}{RED}converte string em base62
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(decode62(arg_mensage[1]))
elif arg_mensage[0] == "basen":
if arg_mensage[1] == "help":
print(
"""{YELLOW}basen{YELLOW}{BLUE} =>{BLUE}{RED}converte decimal em basen
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(
numpy.base_repr(int(arg_mensage[1]),
base=int(arg_mensage[2])))
elif arg_mensage[0] == "url":
try:
if arg_mensage[1] == "help":
print(
"""{YELLOW}url_encode{YELLOW}{BLUE} =>{BLUE}{RED}encode personalidado para url\nencode url_encode safa[] encoding"""
.format(YELLOW=Fore.YELLOW,
BLUE=Fore.BLUE,
RED=Fore.RED))
else:
print(
quote(arg_mensage[1],
safe=arg_mensage[2],
encoding=arg_mensage[3]))
except IndexError:
print(
"digite a sintaxe correta\nncode url_encode safa[] encoding\n ou use o comando help"
)
elif arg_mensage[0] == "unicode_normalize":
try:
if arg_mensage[1] == "help":
print(
"""{YELLOW}unicode_normalize{YELLOW}{BLUE} =>{BLUE}{RED}Transforme caracteres Unicode em uma das formas de normalização['NFC', 'NFKC', 'NFD','NFKD']\n
{YELLOW}NFD{YELLOW}{BLUE} =>{BLUE}{RED}Normalisation Form Canonical Decomposition
{YELLOW}NFC{YELLOW}{BLUE} =>{BLUE}{RED}Normalisation Form Canonical Composition
{YELLOW}NFKD{YELLOW}{BLUE} =>{BLUE}{RED}Normalisation Form Compatibility Decomposition
{YELLOW}NFKC{YELLOW}{BLUE} =>{BLUE}{RED}Normalisation Form Compatibility Composition
encode unicode_normalize str encoding['NFC', 'NFKC', 'NFD','NFKD']\n""".format(
YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(unicodedata.normalize(arg_mensage[1],
arg_mensage[2]))
except IndexError:
print(
"digite a sintaxe correta\nncode url_encode safa[] encoding\n ou use o comando help"
)
elif arg_mensage[0] == "qp_encoding":
try:
if arg_mensage[1] == "help":
print("""{YELLOW}qp_encoding{YELLOW}{BLUE} =>{BLUE}{RED}
Quoted-Printable, ou QP encoding,
é uma codificação que usa caracteres ASCII imprimíveis (alfanuméricos e o sinal de igual '=')
para transmitir dados de 8 bits em um caminho de dados de 7 bits ou, geralmente, em um meio que não é 8- um pouco limpo.
É definido como uma codificação de transferência de conteúdo MIME para uso em e-mail.
QP funciona usando o sinal de igual '=' como um caractere de escape. Ele também limita o comprimento da linha a 76, pois alguns softwares têm limites no comprimento da linha\nencode qp_encoding TXT encode"""
.format(YELLOW=Fore.YELLOW,
BLUE=Fore.BLUE,
RED=Fore.RED))
else:
encoded = quopri.encodestring(arg_mensage[1].encode(
arg_mensage[2]))
print(encoded.decode())
except IndexError:
print(
"digite a sintaxe correta\nencode qp_encoding é utf-16\n ou use o comando help"
)
elif arg_mensage[0] == "idna":
try:
if arg_mensage[1] == "help":
print(
"""{YELLOW}idna{YELLOW}{BLUE} =>{BLUE}{RED}encode personalidado para url\nencode url_encode safa[] encoding"""
.format(YELLOW=Fore.YELLOW,
BLUE=Fore.BLUE,
RED=Fore.RED))
else:
print(idna.encode(arg_mensage[1]).decode(arg_mensage[2]))
except IndexError:
print(
"digite a sintaxe correta\nncode idna string encoding\n ou use o comando help"
)
else:
pass
try:
pass
except IndexError:
print("verificar a saida")
def parse_data(data, my_decode_flag, my_caesar_flag):
my_answers = list()
if my_decode_flag is True:
for name in ('hex_codec', 'base64_codec', 'rot_13', 'utf_8',
'utf_16_be', 'utf_16_le', 'bz2', 'zip', 'idna', 'palmos',
'punycode', 'quopri_codec', 'utf_7'):
try:
result = data.decode(name)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'base32'
try:
result = base64.b32decode(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'uuencode'
try:
result = binascii.a2b_uu(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'quotable'
try:
result = binascii.a2b_qp(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'binhex4'
try:
result = binascii.rledecode_hqx(binascii.a2b_hqx(data))
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'yenc'
try:
decoder = yenc.Decoder()
decoder.feed(data)
result = decoder.getDecoded()
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
else:
for name in ('hex_codec', 'base64_codec', 'rot_13', 'utf_8',
'utf_16_be', 'utf_16_le', 'bz2', 'zip', 'idna', 'palmos',
'punycode', 'quopri_codec', 'utf_7'):
try:
result = data.encode(name)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'base32'
try:
result = base64.b32encode(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'uuencode'
try:
result = binascii.b2a_uu(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'quotable'
try:
result = binascii.b2a_qp(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'binhex4'
try:
result = binascii.b2a_hqx(binascii.rlecode_hqx(data))
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'yenc'
try:
encoder = yenc.Encoder()
encoder.feed(data)
result = encoder.getEncoded()
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
if my_caesar_flag:
for i in range(1, 256):
my_answers.append([
"Caesar_%d" % i,
repr(''.join([chr((ord(c) + i) % 256) for c in data]))
])
my_answers.append([
"xor_%d" % i,
repr(''.join([chr((ord(c) ^ i) % 256) for c in data]))
])
return my_answers
"""Macintosh binhex compression/decompression.
def _load_logo():
_ds9_python_logo_text = r"""8dP08%a&)#!p)*!89##3-N**9&"*@#!J25#3&$JJN$*139K*8b!J)$dJN"3b)*!b6N&B59-a)#!p)*!5-cFi)*!b6N&B59-b)#!p)*!5-6B`)*!b3PT&8NmJ)#!p)*!0-#i`N!BJN$*#8d0"6%8J)$dJN!da,M#3"L#3-N4"9%&058iJ25#3$6!Z-*!')*!b4%&838e"@#!p)*!,-M8e,M#3"L#3JNK*8e428PNJ9%K*8b"'5946)%C*6%8J9d&6)%G&6N95394&4#"#@5"(58e3)&9658j()%C*9&059b#3Cd0268e&6P3J4QPdFe*A)'Pc)#K$+5"3CA4PFL",DA*MD'GPFh0ZCA)J+("PG'9b3'YTFQ0SCf9cFfjPFLjZCA3T,#"LGA3JBACKD@aKBQaP3dp068919#"eEQ4PFL"dD'8J4dj9)'GPEQ9bB@`JF(9LE'PM)'aTBf9ZBf8Z)*!M3dp068919#"'Eh)JFfpeFQ0PFb"cC@8JD(4dF$S[,hGhGbjVDA*MD'GPFh0ZCA)ZEQ9d)*"Y3dp068919#"*E@&RC5"dHA"P)(GTG'KTEL"(58e31L"(58e3Ae*(3Pp*68&(45#3)N0268e&6P3J8f9aG@9ZBf8JCQpb)%j"@%P6-b!J)$SJ8N9%,#"(8N9&6L`J3Na945#3F%914##3rb#3rb#3rb#3rb#3rb#38[q3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq30raj-B[krj$rrj"fq8dq9l,rN2rrN(INkZaRmIq3&IMSrj!4k2[rN!Iilqk3#1hmrj$rrj!mC-[rN"A3@Iq3$IVVrreTb2q3"[0RBR0cFh"F2$Be00ErN2rrN#l8YlCrHAUVm2q3"NClrj!9`acrN!frD[[k@T,rN!E)+0,lN!6kpH$9hrcrN2rrN#kU%4qXfm)k6GlrN!6J%c,`rj!8a!crN!fb2IAk@B,rN!AqXb26rrr!QIq3rrq30+S!DIcrrlF1E2lrrrk5#8Qjrj!*rHfpTlRNqrq3"-B*rrrrll([rj!&pr'c,I2j@(rrN!@p2c2Crrq@5[q3rrq30+S#M[rrrrFI(qVrrr3q-V9jrj!)rUXiF*5!3hVYrrrrb!MrN!5SBH$rrrriBAkd+I,j@(lrN!Afj2Mrrrq10[q3rrq30+S$N[q3"$F6b[rraJ0qm@$arj!(U5r'rIrqmeY9mIrrb`MrN!6pTMR3rZG950ke+2,j9hlrrrrqelM8m[hrrimdrj!%r[Rmrj$rrj!YUJ15rj!%14,&rrYT"p6rQDArN!Eq1RRqrj!%bbDjrrr1"rq3"IQ5-,CdNH[rYL6Ij9"prrrr[NNj6PjPD'G22@9H8dBj0Q[qrj$rrj!XUJ+2rrrrq53AeIrE*8,frq09p2q3"IS@SIq3"H)QS[rrc`IrN!EjA#r$rrrrYa"SDbCprrrrl0l0iHlcp*!%mqRA`DUZdIq3rrq3,DS!B2[rrli1-[MrP3@8r[rl5-hrN!BhE[q3"F3N[Irrc`ErN!IL)C6rrrqi*[,k@AcrN!6qd(KNT[(rN!6pcRjRmrq3rrq3,US"0)klVLS1TIh6,`bjqrlVAeRKrj!&XbQJr2rqhdKRp[rrc`ErN!KL-[hrrlNQm[TCI2q3"[V6DM#1jHHP4La'VrcrN2rrN#kU!ih"F$j)U[IeJ'0MJH[kUfjRQ[q3"IUf8@CeF9D4lIrrrmi&rj!%qVjaU$Y*Y,MeZLAbqPPlrj!)pVN`,9HC`pR`rj$rrj!`UJ15rrrprj!9q-iVFqrrN!A*"Iq3"1Z3!)b@NA**@HDP'r$k@AVrN!Ejp2IkebSXl2clqrlrN2rrN#qU!j,rN"RiZHrrN!DU![MrN!Z0+9lfmNPVrIq3"0G&'6eHEMBKB@0JAEhrN2rrN#qH!j,rN#'R1NVerj!,lZ[hkQBcS2hrN!6bi1MTN!6Pbk'&K0IrN2rrN#kU44LBrj!KiGVcrj!2ppMLrIq3rrq332cPbq(rN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN2rrN*MhdE+MS+rBqrq3rrq3FH+3!$`D#`-"#4jNf[q3rrq3E[Uh,3-!N!F"-H6rN2rrN'cjL`S!N!YAp2q3rrq3D[f'#J!!!bNf"J#3"JE!rj$rrj"TrVF6!!!+C0cSN4-!N!CVr[q3rrq3D2!Y!!!-QrArrrb*!`#3"6MZrj$rrj"RqRF!!"kmrj!&ldN!N!8Ie2q3rrq3Cm)6!#Hrr[q3"V!!N!82a2q3rrq3C[01!#(!r[q3"qX!N!8'Zrq3rrq3CUF+)XVqrj!)l`#3"3'frj$rrj"Pm8G`jrq3#Zm!N!8"Y[q3rrq3CIRNqIq3#qm!N!8#Yrq3rrq3Fqm!N!8&Z[q3ir(*TBYrIBLNbrIrN)A[!*!&#VrrN0rjcBj&%3F%!J%!!33)'@+mp[q3G[A2XCjY-aB9-RE-qqm!N!84a[q3#I$+cH,krj"!p0IFl2hrN!r0SE[rN&hedTYN3c53#68k5@LKhrq3#E%C!`#3$"&8b2lrN%chd1$frj!Ll*Jp'JN"!*!''''h!*!&'FrrN!MC3KFC*%#Kr2q3%2crlDpC3E$lrj!1rE9'0%23rj!2m-Z"0"iK+MeYU0Ihrj!,I3%8f2q3'Ih!lrq3'IH9h2Iqrj!JrFjD&J#3%!%hfIq3#+%!N"!DSrRrN%[Y15P9V2IrN"lqf%8$!*!-$`#3"56Drj!(pdN"!*!%&plrN"#CJ$i(!!!Berq3$ZJh!!!)Vrq3$2VIN!"$%3#3"`)E@,Rdrj!*JJ!'`rq3'FCCpIq3'PJ+3(k[f[crN"cjPJX!N"-#S2q3#+%!N"%'L[MrN%ZB"3!!60VrN"h2*`#3&$,Rrj!(X!#3"KMVrj!3FJ#3"ScrN!l@(J!!!*6rN!VpaPS0!*!0!d#irj!)J3!(hIq3'28k@2q3'p3K!!%)%#0DNVhJrIq3&[Cq"`#3&CRrN!LK!!%B6iQkfZAHa)p-%3#3"3U-rIq35ZBA!!!"-pArN"[T1`#3&86irj!'p93!N!C4r[q3%*8!N!CGrj!1e"X!!!##rj!*h'`0!3#3%!Yhl[q3"RX!#1[rN"IlL!&`rj!ErQN!N!B"$LK0J,(Dl[hrN"$pNJ`!N!F+)NGhRE5e8!#3"jcrN!LP+),5p[q3"r2"433!N!39YIq35d)!!!!"8IIrN"U""3#3&@6rN!I5&`#3"3LTrj!4V`#3"NrrN!l$#J!!!(IrN!IlX$%#!*!'$$%M!3#3#34Kl2q3"A%!"XrrN"I)'J#%rj!FX`)!N!S"%d"i`rVqrj!0b4F!N!B2AUcNr[q3"0F2!*!&!ClrN!MMiIq3$2"K"!#3"#Mbrj"+H!#3"!Zarj!Ck48!N"D5rj!(K3#3"LRJrj!4a!#3"NRrN!k3!!#3"(crN!EiN3`!N!B$3Dhad$)"!*!*"(Mqrj!%C3!%UIq3&[*0!!#@rj!Ff4i!!53*!*!+!5H(hIq3#rBf!*!'*F[rN!Ma33#3"35Prj!Ap&i!N!9qqrq35D!!N!91qrq3&rf$!3#3&32-rj!'k5i!N!C+rIq3%G%,!*!&4rq3$ISp!*!%K[q3"I&`!3#3"L#Uq[rrrq44!*!+%-ArN!4A!!&pr[q3&BN&!!#Srj!FkcX!!#D8-`-!N!S$(RcRrj!)rCJ#!*!%!cM3r[q3#2PH!*!&#V$rN"ME+J#3""[Crj!Rj2crN##i#3#3"!hZrj!Akbm!N!F',dBr%3#3#LVTrj!'TJN!N!CYrj!5fK`!N!9&rj!0a"-!N!53!2q3"2CZ"J#3"301eIlrN!AVEJF!N!J"E2hrrrp*!!"@prq3&0)@!!!!Z2q3(2K3!!!$C1+#(`)!N!S"2-,mrj!'j$%!!!!(,SVLrj!+r@d!N!86`rq3'2f6!*!&KIlrN#DCp[q3)-)4!*!&arq3&lX$!*!'%CMNq[5k03%!N!KPq[q3"Ie+!*!(NIq3%Z3Z!*!&3[[rN!aS!3!!!!+JrrrrrT!!#3#3"3*EjIq3#2D%%!#3##hkrrrr23!!,ZhrN"2d9!%!!!$'rj!G@J!!!!E"rpKV"J#3#aQZrj!'S!%!!"+4mrq3$2jb!*!&(YVrN"RZ&`#3"$6Vrj!Pp%IXrj!Jb"8!N!@Zrj!AE!#3"JQ9rj!&ebd!N!F#V2q3"YJ0!*!(Y[q3%["%!*!&12$rN![X$`#3"!UcrrrreJd!N!8"4ZrrN!VmP3X!N!F,q2rrrc%!!!A5rj!6V3-!N!6Arj!G@J#3"%(`rrl6AJd!N!S4Z[q3"23q!!!-U2lrN!hjA3#3"66jrj!Cr@`!N!3-ZIq3*EBIhrq3)-`C!*!&ZIq3&ZNe!*!'3IMrN!E!#`#3"Jlcrj!'M`-!N!B%e[q3%[jN!*!&)GErN!VqL3%!N!3@b2rrmNi!N!BMirq3$2bF"!#3"J,irrrr+!!!!(hrN",P-`#3"!MNrj!G@J#3"!@crrrrpF*4#J#3#5hYrrrrb4F!!%rcrj!1eaX!N!9Rrj!EV3N!N!4qrj!NrAJ&eIq3)-mE!*!%$16rN"E+&!#3"3+Drj!(q'3"!*!&6rq3"[PE!*!(%plrN"1#!*!&"UMrN!VV03#3"5,Grrqq#3#3"3HArj!1pfN$!*!&"rMrrrmP!!!!-q6rN"'9"!#3""lUrj!G@J#3"96irj!%pTSJ!3#3#*Iqrrqa"J!(Z[q3$Z98!*!&!UhrN!rmmqcSjqMZprq3"0m@!*!%3Iq3*2""!p6rN#$3(!!!!!*YrIq3&U8#!*!&)p[rN!M2#`#3"!5Arj!'mcX!N!FSj[q3%jm!N!C0qrq3#EB%!*!&0rMrrQF!N!BZj[q3$q)H!*!&%rRrrrmU!!!!"U2rN"$[0!#3"6Varj!G@J#3"4c5rj!'e8F!N!K%m2rrX!8#G[IrN!h+2J%!N!8QhIq3$ILlFciG#3)-*P5Gm[rrrL`!N!3Dmrq3)pi2#YIrN#$4(3!!!"cMrj!AF!#3"QAlrj!*53#3""M2rj!'m#F!N!G'mIq3%ld!N!B,XIq3#2TA!*!'C2rrk#m!N!CZrj!4FJ#3"56jrrrr1!#3"$[hrj!2V`X!N!9HqIq3(@%!N!8"S2q3"r"*!3#3"KRDrrq`(j2krj!,p,pR#J%!N!CbrIq3#rZX0!F"!*!("#HMq2pA!*!%%G(rN#1P!"2Erj!JdKd!!!"1rj!B23#3"3,%rj!+S!B!!!!`prq3"[!U!*!(F[hrN"2D!*!((pVrN!I1'J#3"TcrrmN@!*!'U[q3%D-!N!8rqrrrrdm!N!3,V[q3$e8!N!8#N!$rN"jb!*!'DIq3#0FE!*!'"-rrrpc+r2q3#IVFQ$i5!*!)$Y(rN![VG3d!N!`1GI9i!*!%#lIrN#,pB`!Hi2q3)0-H!!!!0pler2q3&1mJ!*!&1I2rN!VD)!!!!'(rN!Id2J#3"llrN"6`"3#3"d,Drj!'J!%!N!84c[rrY`J!N!E'rj!4R3#3"@(prrrrE`#3"8Vprj!0jJi!N!8)c[q3(S)!N!C"rj!*C`#3"mRrN![ppEpP)`#3#J*Yq[q3#[&M!`#3$J1"M!#3"!DMrj!LkM3!+qArN#$8(`!!!!)Q5eKGN!9HC(53!-$Zqrq3#0!9!*!%"k$qrj!+r83!!!#Drj!(qQ%!N!B8q[q3&28C!*!)4YlrN!64(J#3"MlYrrq[!3#3"XMrN"&d!*!%!BMrN!59!3#3"!66rj!-rBX"!*!&,2[rN"k4!*!'+rq3#D8"!*!'cIq3#H#RF5d"!*!-,ZMrN!Y`"!#3"KY4F(KS33N!!!!&83#3"!18rj!LaK%!+Ufm[X$%bpcfrj!Ce5!!N"%9CYRrN!H`#`#3"%hkrj!-IJ!!%XhrN!L8!`#3"8ErN"Ah-3#3#6rerrl2+`#3"hcrrrqa!`#3"V6rN"$e+J#3"!bhrj!%[3m!N!9PqIq3#q8P!*!&"TArN"qI!*!')rq3#EX+!*!&"p(rN!ITH4-(!*!1*F6rN!Zk#`#3"4Q4j[Ipr[[cdeX*!!!%!*!%!BhrN"hPPe0$G'`"!!-+#``-$3i5'MpmaIErN"AA)3#3%J%ESIArN!@5!J!!!$ICrj!0Y3)!21crN!M5#`#3"8(rN"Aj4`#3#30AM9S8!*!("p2rrrql#`#3"S,rN!rpPJF!N!3HkIq3"13T!*!&$m6rN!VkHJ%!N!8kl2q3(kS!N!BMrj!*`a%!N!85e[q3"Ibr333!N!i",llqrj!+mdJ!N!8NZrlrN!IcK3N!N!H*rj!Dqq'F-!3!!!!$!*!+!3SC3Dcmrj!8f#)!N"3-E1hrrrrqE3!!!#R(rj!1d4!!F[lrN!Ml*J#3"3c4rIq3%rYD!*!%'4X!N!i"6IMrrrr1'J#3"Mrbrj!0rFXD!*!&9rq3"IeE!*!'5HVrN!Qh&`#3"3ZXrj!JY3#3"L2rN!Qp$3#3"5(Hrj!%rC`9!*!1!3YLhIq3$-S&!*!%$+RrN!VeBJ#3"J',rj!BqmpY*J%!N!`#!aC-JUl6q2q3&YSN!*!%"*!'!`)"!*!)"((rrrrp43!!&-Iqrj!1h#-!`2rrrrllN!CL!*!'*Bh4mI[lr2hqrj!-r'X!N!4ET3N!N!d0[[q3"1Sa!*!'#k6rN!cq`LJ!N!8(V2q3"Ui#!*!&"@llrj!(e#N!N!CVp[q3),m!N!BMrj!*L3#3"METrrrrqT)"!*!0#d+)h[q3$R-!N!9LqIq3#qS9!*!&!T(rN"EVded&!*!)!`!!!"j(FkIEr2q3'p`Q!!!!%XhrN!6filb"1JF!N!F,errrr"F!(-2rN"$T1#[`rrrr``m!N"!#$#*$FD,9r[q3#Ijk!*!%GIbJ"`#3#`4irj!'D!#3"a+br2q3#HGc$3#3"MhYrj!'k6F!N!B%@q2rN!6iVKJ!N!BkmIq3)FF!N!BMrj!)rN8!N!C1pIrrrlN3!*!*##*!F+MCm2lrN!Mqrj!&m%!!N!3%`rq3$2eV!3#3"!@Erj!@q[ESeV5PUV5qap(DR3!!"F(brIq3(YdQ!!!!!@Vprj!'rZke43)!N!8$N[rriJ%GYIlrN"$a4R6mrrrrm9!!N"8(&N+Bf[hrN!H$!*!%LrrlN!!3!*!*"',Yrj!'`JS!N!F1ClcJp2[jmGZmG#)$!*!'#+hrN!IqR!#3"`)PEk5XL%!-!*!'-0MrN#,1!*!')rq3#0iA!*!'ErlrrrP0!*!'!K-mK,MApIq3$1$'rj!&fb3!N!3Pl[q3$Dd*!*!%#+VrN#+e!!!3fIq3)0iR!*!%%ZVrN!RZG!X!N!9Pq[q[&DVmrj!4p9E(rj!&cc!#!*!,"!#3#J-PF0Vkrj!&K3#3"+(rrrQK)`%!N!8"%AVYrj!(meN!N!N0+N"'4$`Q#`#3#9rdrj!)mM8!N")",mRrN#29!*!'*Iq3"rk4"!#3"U$rrrrB)J#3"3YXc2hrN!rd@CRrN!A-%J#3"&,hrj!0f"3!N!3-Zrq3)V8!!#(Krj!Jh5B!N!@Mrj!+qhN#!*!%426rVF$prj!5qBVprj!'jSTSA%mM!3#3"S4V,J-!N!S9GZ6rrrrqJ!#3",MrN!6CEaS!!!)RE-ErN!VI(3#3'#rVrj!+[Jm!N"%qe[q3*0X!N!BTrj!(pM-!N!B#h2rrrlX0!*!%(FIprj!4N`D(rj!&`JB!N!4Ur2q3$HmD!*!%%YIrN#+e!!"%m2q3)0SN!*!&N!$rN![Y4!#3"#[[rrlrN"6pl2q3#Ihpr29`!*!'erhlqC!-q[lrrrrqH`#3"-rrN!Apq16GlrVprj!-e8J'!*!8!NVJrj!,rTB-!*!1#'6crj!Ph`#3"M$rN!EqV!-!N!BPprrrrk)"!!!!$UlrN",Q)J"Srj!&[`%!N!4er[q3$ISF!*!%'r,rN#+e!!"Zr2q3)03I!*!&Trq3$*S!N!3El2q3*F3!N!EArj!6rA8!!!!,h2q3'HfV64d&!*!2!b5'k2q3$IH2%3#3#`-aS[ArN#EN!*!'22q3"ZNr!*!(Crcrrrq'!*!%22VrN"(mI`-!52q3"F!%!*!%FIhrN!he'`#3"$[rN#1e!!#jrj!Kc"N!N!A0rj!-dJ#3"!rTrj!Pc!#3"YIrN"2mC`!!!#$Nrj!EqY'UH8mZ'4H3#"mcACVErIq3$rUc+3B!N!F((SAJrj!Sj`#3"NhrN!AqL3)!N!B*V2q3"(!!N!4Xrj!5fK-!!$2rN!A($!#3"',krj!0jaJ!N!4`rj!MY3!Gprq3)F35!*!%$I2rN!cI!*!%"qMrN#A-!*!'erq3%rYA!!!!11crN%(`ReBN#J34-QDQlIq3+ZN!N!CRrj!&ZaF!N!FNl[q3"'-!N!4Jrj!4p&`!!!"*rj!&e4i!N!3mm[q3$F)1!!!!"UlrN#1e")Vqrj!KZ!J!N!4%qrq3$-3!N!3#jrq3*F`!N!EArj!6q8F!!!"9prq33rRcm1rapI[rN#cV!*!'KIq3"0XZ!*!("B[rN!9J!*!%+ZrrN!rfL`S!!!1)rj!&kMF!N!34iIq3$2k4"!!!!#6Crj!MY5MMrj!LU3%!!!!#K[lrN![qJJ#3"!,Rrj!Pc3%!N!3%fIq3%rF[!!!!HIlrN(EX!*!&!UhrrrrQ23%!N!Fjk2q3"AB!N!3(Q2q3$IlaF3X!!!!Jf2q3"IaL!*!&PIlrN![i2J#3"&Rlrj!Mb+MrN#13!!#3"!r#rj!-h#X!N!3-kIq3*G%*!*!%%prrN"2d&3!!!DVrN(IY!*!&'Flrrmif!*!)%EhrN!Di$3#3""29rj!,p+3X!*!%"jArN!Hf!*!&,H$rN!ZZ!3!!!!@jrj"*E!#3"#Ihrj!,hNF!N!8MlIq3*Hk-H*!%N!$crj!6k3%!!!,Rrj"hk`#3"8,aqD-L!3#3"`+9qrq3"[%p!*!&00,rN!Imfj3c#!#3"!0bp2q3"qie!*!%!Q$brj!*c5N!N!4*m2q358N!N!3mVT!*VCe`'`)!N!9*pIq33-)!!!!`r[q3GqB!N!3$NY9L#`#3#!CPqIq3#)8!N!BdZ2,mq1hGUPiP!J#3"3GXm2q3#2kM"`#3"!GKjIhrN!Aj[M8!N!3([rq35IiT!*!BE2crN%#B!!!"H2q3H0d!N!3QAaX!N!N$DI2rN!R#!`#3"JY*BeJp&3%!N!F(G2MrN!Vk8!#3"Lb%b[$jjVCN%!#3"!0Rrj"+laF!N"F%Q[q33@d!!!kkrj"icJ#3$`q-p[q3#ZBZ!*!6$jAmrj!-jN)!N"%"6[(rN%V5%!#3&bIYrj"!q&)!!$,erj"iZJ#3$33aZ[VrN![lK!#3%K#Mq[q3$YT1!J#3$J09i2q35lJ,!*!9#NA(rj""l6m!!SRrN(QK!*!+""-pPq,rN!l`4!)!N!m@R[hrN"$UG48#!*!+!4*kkrq36+)'!*!("3d8("q3"L3a5hHhl2q33Z)T!#RDrj"jK!#3##4EPG$mrj!4j9%#!*!0-VMrN"6-EK`!N!J@D-RrN%kH"3!!!!JeAS+IZpIcrj"1e"!#Q[q3HIjJ!!!"%d&[U1$jr2q3&IH[9#S6"`)%#"!I-Nef[rArN"EppmUDHfTTGj6$pIhrN%qH"4"5V1Vkr2lrN&+k!h(hrj"jq@BU9k2Al[hrN"[fj0R5d0(6eplRp2lrN(1P@-Aerj"AS'lbrj"lj16prj#Hjr2rN&RQq2q3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3rrq3M300"""
import binascii
_ds9_python_logo = binascii.a2b_hqx(_ds9_python_logo_text.encode("ascii"))[0]
return binascii.rledecode_hqx(_ds9_python_logo)
if binhex == 2 and binhexline:
l = len(binhexline)
eof = 0
while l > 0:
# print "l=%d" % (l)
try:
curbin, eof = binascii.a2b_hqx(binhexline[:l])
# print "BinHex: %d bytes decoded from %d/%d chars, EOF: %d" % (len(curbin),l,len(binhexline),eof)
binhexdata += curbin
binhexline = binhexline[l:]
break
except binascii.Incomplete:
l -= 1
if eof:
# print "BinHex: done hqx decoding, size: %d" % (len(binhexdata))
binhexdata = binascii.rledecode_hqx(binhexdata)
hqxsize = len(binhexdata)
# print "BinHex: done rle decoding, size: %d" % (hqxsize)
# check for the header:
fnlen = ord(binhexdata[0])
# print "BinHex fnlen=%d" % (fnlen)
if hqxsize <= 22 + fnlen:
# print "BinHex: invalid header / file truncated! writting out raw data."
hqxfilename = [None, "BinHex.dat", None, None]
hdrlen = 0
else:
hqxfilename = [
None,
unicode(binhexdata[1:1 + fnlen].strip(),
"latin-1"), None,
binhexdata[2 + fnlen:2 + fnlen + 4]
def decodeData(str):
return cPickle.loads(binascii.rledecode_hqx(binascii.a2b_base64(str)))
def decodeData(str):
return cPickle.loads(binascii.rledecode_hqx(binascii.a2b_base64(str)))
def test():
for _ in range(9999):
try:
binascii.a2b_uu(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_uu(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.a2b_base64(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_base64(fstr(), newline=fbool())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.a2b_qp(fstr(), header=fbool())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_qp(fstr(),
quotetabs=fbool(),
istext=fbool(),
header=fbool())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.a2b_hqx(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.rledecode_hqx(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.rlecode_hqx(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_hqx(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.crc_hqx(fstr(), flong())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.crc32(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.crc32(fstr(), flong())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_hex(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.hexlify(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.a2b_hex(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.unhexlify(fstr())
except (binascii.Error, binascii.Incomplete):
pass
def test_rlecode_hqx_rledecode_hqx_round_trip(self, payload):
x = binascii.rlecode_hqx(payload)
self.assertEqual(payload, binascii.rledecode_hqx(x))
else:
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
for fName in onlyfiles:
if (fName.find(".rvd") > 0) and (fName.find("HD") > 0):
files.append(fName)
if args.output:
out = args.output
else:
out = "ServiceCenterAddressBook.xadr"
for f in files:
with open(f, "rb") as binary_file:
# Read the whole file at once
data = binary_file.read()
a_data = binascii.rledecode_hqx(data)
for line in iter(a_data.splitlines()):
host = {}
if (line.find('10.') >= 0):
arr = re.split(' ',line)
for item in arr:
room = ""
bldg = ""
if (item.find('10.') >= 0):
if (item.find("HD") >= 0):
room = arr[arr.index(item) - 1]
bldg = arr[arr.index(item) - 2]
elif (item.find("ite") >= 0):
room = arr[arr.index(item) - 1]
bldg = arr[arr.index(item) - 2]
else:
def searchBitMap(self, db, keyword, encoded=True):
self.SearchDocIDList = []
#self.webDocs = {}
self.searchWords = ''
self.wordList = []
self.startTime = 0
self.elapsedTime = ''
self.encoded = encoded
word = ''
totalResult = 0
self.searchWords = keyword
if not self.searchWords:
#CommonFunctions.ShowErrorMessage(self, "Failed to Export Phone List. Error: %s"%value)
return
if encoded:
query = "select keyword, compressed from %s where (Keyword = " % Constants.TextCatBitMapIndex
else:
query = "select keyword, bitmap from %s where (Keyword = '" % Constants.TextCatBitMapIndex
i = 0
for word in string.split(self.searchWords, ' '):
word = word.strip().lower()
word = word.strip('"')
if word not in Globals.EmailsStopwords:
i += 1
self.wordList.append(word)
if i == 1:
query += db.SqlSQuote(word)
else:
query += " or keyword = %s" % (db.SqlSQuote(word))
query += ")"
if self.wordList < 0:
return None
#print query
bitMap = []
docIndex = 0
#print query
rows = db.FetchAllRows(query)
totalResult = len(rows)
"""
if totalResult < len(self.wordList):
self.elapsedTime = CommonFunctions.ConvertSecondsToYearDayHourMinSec(time.time() - self.startTime)
self.MessagesHeading = "%d Results for %s (%s)"%(len(self.SearchDocIDList), self.searchWords, self.elapsedTime)
return None
"""
if totalResult < 1:
self.elapsedTime = CommonFunctions.ConvertSecondsToYearDayHourMinSec(
time.time() - self.startTime)
self.MessagesHeading = "%d Results for %s (%s)" % (len(
self.SearchDocIDList), self.searchWords, self.elapsedTime)
return None
if totalResult == 1:
if self.encoded:
bitMap = binascii.rledecode_hqx(rows[0][1])
else:
bitMap = rows[0][1]
elif totalResult > 1:
if self.encoded:
bits = binascii.rledecode_hqx(rows[0][1])
for bit in bits:
bitMap.append(bit)
else:
for bit in rows[0][1]: # get the bitmap of first word/row
bitMap.append(bit)
i = 1
while i < totalResult:
row = rows[i]
i += 1
index = 0 # start from the beginning of the bitmap
if encoded:
bits = binascii.rledecode_hqx(row[1])
else:
bits = row[1]
for bit in bits:
if self.searchWords.startswith('"'):
bitMap[index] = str(int(bitMap[index]) & int(bit))
else:
bitMap[index] = str(int(bitMap[index]) | int(bit))
index += 1
#print bitMap
docIndex = 1
for bit in bitMap:
if bit == '1':
#if len(self.docIDString) >= 1:
# self.docIDString += ','
self.SearchDocIDList.append(docIndex)
#self.docIDString += str(docIndex)
docIndex += 1
if len(self.SearchDocIDList) == 0:
return
if keyword.startswith('"'):
keyword = keyword.replace('"', "'")
msgOutputPath = os.path.join(self.MessageOutputPath, keyword)
try:
os.makedirs(msgOutputPath)
except:
pass
for key in Globals.MessageDict:
for msg in Globals.MessageDict[key]:
if msg.DocID in self.SearchDocIDList:
destPath = os.path.join(msgOutputPath,
os.path.basename(msg.filePath))
if not os.path.isfile(destPath):
shutil.copyfile(msg.filePath, destPath)