#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#
|
##@package
|
#
|
# @todo:
|
#
|
# @author: Alee
|
# @date 2018-7-18 ÉÏÎç11:22:43
|
# @version 1.0
|
#
|
# @note:
|
#
|
#---------------------------------------------------------------------
|
|
import struct
|
import string
|
import datetime
|
import os
|
import binascii
|
import socket
|
import sys
|
|
|
#pythonµÄ¶ÁÈ¡/дÈë¿â
|
#Òª½øÐз´×ª¸ßµÍλµÄ»°£¬¿ÉʹÓÃ!·ûºÅ£¬Èçstruct.unpack_from('!B', buf, pos)
|
|
#------------------------¶ÁÈ¡
|
def ReadBYTE(buf, pos):
|
curValue = struct.unpack_from('b', buf, pos)
|
pos += 1
|
return curValue[0], pos
|
|
def ReadWORD(buf, pos):
|
curValue = struct.unpack_from('H', buf, pos)
|
pos += 2
|
return curValue[0], pos
|
|
def ReadDWORD(buf, pos):
|
curValue = struct.unpack_from('i', buf, pos)
|
pos += 4
|
return curValue[0], pos
|
|
def ReadFloat(buf, pos):
|
curValue = struct.unpack_from('f', buf, pos)
|
pos += 4
|
return curValue[0], pos
|
|
def ReadDouble(buf, pos):
|
curValue = struct.unpack_from('d', buf, pos)
|
pos += 8
|
return curValue[0], pos
|
|
def ReadString(buf, pos, _len):
|
curValue = struct.unpack_from('%ds'%_len, buf, pos)
|
pos += _len
|
return curValue[0], pos
|
|
|
#----------------------дÈë
|
def WriteBYTE(buf, value):
|
buf += struct.pack('b', value)
|
return buf
|
|
def WriteWORD(buf, value):
|
buf += struct.pack('H', value)
|
return buf
|
|
def WriteDWORD(buf, value):
|
buf += struct.pack('i', value)
|
return buf
|
|
def WriteFloat(buf, value):
|
buf += struct.pack('f', value)
|
return buf
|
|
def WriteDouble(buf, value):
|
buf += struct.pack('d', value)
|
return buf
|
|
def WriteString(buf, len, value):
|
buf += struct.pack('%ds'%len, value)
|
return buf
|
|
|
|
#»ñµÃµ±Ç°ÏµÍ³Ê±¼ä
|
def GetCurrentDataTimeStr():
|
curTime = datetime.datetime.today()
|
curTimeStr = str(curTime)
|
curTimeStr = curTimeStr.split(".")[0]
|
return curTimeStr
|
|
#»ñµÃϵͳʱ¼ä(²ÎÊý -> ʱ¼äÁбí)
|
def GetDateTimeByStr(timeStr):
|
timeStr = timeStr.split(".")[0]
|
return datetime.datetime.strptime(timeStr, "%Y-%m-%d %H:%M:%S")
|
|
|
|
#×Ö·û´®×ª»»ÎªÕûÐÍ, Èç¹û²»ÄÜת»», ·µ»ØĬÈÏÖµ
|
def ToIntDef(input, defValue = 0):
|
try:
|
result = int(input)
|
return result
|
except ValueError:
|
return defValue
|
|
|
#×Ö·û´®×ª»»ÎªÕûÐÍ, Èç¹û²»ÄÜת»», ·µ»ØFalse,ÔÖµ
|
def StrToInt(input):
|
try:
|
result = int(input)
|
return True,result
|
except ValueError:
|
return False,input
|
|
|
#16½øÖÆÑÕɫת»»
|
#"#FFFFFF"--"255,255,255"
|
def HcToSc(h):
|
h="0x"+h[1:7]
|
red=string.atoi(h[:2]+h[2:4], base=16)
|
green=string.atoi(h[:2]+h[4:6], base=16)
|
blue=string.atoi(h[:2]+h[6:8], base=16)
|
cStr=str(red)+","+str(green)+","+str(blue)
|
return cStr
|
|
#"255,255,255"--"#FFFFFF"
|
def ScToHc(s):
|
red=hex(string.atoi(s.split(",")[0]))[2:]
|
green=hex(string.atoi(s.split(",")[1]))[2:]
|
blue=hex(string.atoi(s.split(",")[2]))[2:]
|
hStr="#"+str(red+green+blue)
|
return hStr
|
|
#16½øÖÆת»»
|
#"0xFFFFFF"--"255,255,255"
|
def HdToSd(h):
|
red=string.atoi(h[0:2]+h[2:4], base=16)
|
green=string.atoi(h[0:2]+h[4:6], base=16)
|
blue=string.atoi(h[0:2]+h[6:8], base=16)
|
cStr=str(red)+","+str(green)+","+str(blue)
|
return cStr
|
|
#"255,255,255"--"0xFFFFFF"
|
def SdToHd(s):
|
red=hex(string.atoi(s.split(",")[0]))[2:]
|
green=hex(string.atoi(s.split(",")[1]))[2:]
|
blue=hex(string.atoi(s.split(",")[2]))[2:]
|
hStr="0x"+str(red+green+blue)
|
return hStr
|
|
def GetPercent(value1, value2):
|
if value2 == 0:
|
return 0
|
return int(float(value1) / float(value2) * 100)
|
|
|
|
def OpenFileForWrite(fileName):
|
dirName = os.path.dirname(fileName)
|
if not os.path.isdir(dirName):
|
os.makedirs(dirName)
|
|
if os.path.isfile(fileName):
|
return open(fileName, 'w')
|
return open(fileName, 'a')
|
|
|
|
|
#º¯Êýµ÷ÓÃ
|
def ParseNameGetObj(curCallObj, callName):
|
callList = callName.split(".")
|
if len(callList) <= 1:
|
return None
|
|
for curCallName in callList:
|
if hasattr(curCallObj, curCallName) != True:
|
#ÎÞ´ËÊôÐÔ
|
return None
|
curCallObj = getattr(curCallObj, curCallName)
|
return curCallObj
|
|
#»ñµÃÖ´Ðк¯Êý
|
def GetExecFunc(curCallObj, callName):
|
curCallObj = ParseNameGetObj(curCallObj, callName)
|
if curCallObj == None:
|
return None
|
|
if callable(curCallObj) != True:
|
#²»¿Éµ÷ÓÃ
|
return None
|
|
return curCallObj
|
|
#×Ö·û´®Òì»ò´¦Àí
|
def str_xor(astring, xornum=150):
|
a=[]
|
for x in astring:
|
a.append(chr(ord(x)^xornum))
|
return ''.join(a)
|
|
#½âÎö·â°ü
|
def ParseBuff(buff):
|
result=''
|
for i in range(len(buff)):
|
if i%2==0 and i!=0:
|
result=result + ' ' + buff[i]
|
else:
|
result = result + buff[i]
|
return result
|
|
def b2a_hex(data):
|
return ParseBuff(binascii.b2a_hex(data))
|
|
def GetHostName():
|
return socket.gethostname()
|
|
def GetHostIP():
|
return socket.gethostbyname(GetHostName())
|
|
|
def compact_traceback():
|
t, v, tb = sys.exc_info()
|
tbinfo = []
|
if not tb: # Must have a traceback
|
raise AssertionError("traceback does not exist")
|
while tb:
|
tbinfo.append((
|
tb.tb_frame.f_code.co_filename,
|
tb.tb_frame.f_code.co_name,
|
str(tb.tb_lineno)
|
))
|
tb = tb.tb_next
|
|
# just to be safe
|
del tb
|
|
info = ' '.join(['[%s|%s|%s]' % x for x in tbinfo])
|
return t, v, info
|
|
import base64
|
import urllib
|
import urllib2
|
|
#---------------------------------------------------------------------
|
## ¼ÓÃÜËã·¨ÐèÒªµÄ¶¨Òå
|
Def_NumEncodeCnt = 3 # ¼ÓÃܵĴÎÊý
|
Def_NumXorKey = 151 # Òì»òµÄkey
|
|
## ¹«Ë¾ÄÚ²¿½âÃÜËã·¨
|
def GetDecodePwd(strPwd):
|
strResult = strPwd
|
for index in xrange(Def_NumEncodeCnt):
|
strResult = base64.b64decode(strResult)
|
|
tempResult = ""
|
for index in xrange(len(strResult)):
|
tempResult += chr(ord(strResult[index])^Def_NumXorKey)
|
|
return tempResult
|
|
|
## ¹«Ë¾ÄÚ²¿¼ÓÃÜËã·¨
|
def GetEncodePwd(strPwd):
|
strResult = ""
|
for index in xrange(len(strPwd)):
|
strResult += chr(ord(strPwd[index])^Def_NumXorKey)
|
|
for index in xrange(Def_NumEncodeCnt):
|
strResult = base64.b64encode(strResult)
|
|
return strResult
|
|
|
|
#---------------------------------------------------------------------
|
## UTF-8 <==> GBK
|
def gbk2utf8(content):
|
if type( content ) is not str:
|
content = str(content)
|
|
try:
|
return content.decode('gbk').encode('utf-8')
|
except:
|
return content
|
|
|
def utf82gbk(content):
|
if type( content ) is not str:
|
content = str(content)
|
|
try:
|
return content.decode('utf-8').encode('gbk')
|
except:
|
return content
|
|
|
## GETÇëÇó
|
def DoGet(url, data=None, headers={}):
|
if data:
|
request = urllib2.Request(url + "?" + urllib.urlencode(data), None, headers)
|
else:
|
request = urllib2.Request(url, None, headers)
|
response = urllib2.urlopen(request, timeout=5)
|
content = response.read()
|
response.close()
|
return content
|
|
|
## POSTÇëÇó
|
def DoPost(url, data, headers={}):
|
try:
|
data = urllib.urlencode(data)
|
except:
|
pass
|
|
request = urllib2.Request(url, data, headers)
|
try:
|
response = urllib2.urlopen(request, timeout=30)
|
content = response.read()
|
response.close()
|
except:
|
content = "error timeout"
|
return content
|
|
|
FileTypeDict = {
|
'.txt':'text/html',
|
'.html':'text/html',
|
'.htm':'text/html',
|
'.bmp':'application/x-bmp',
|
'.ico':'image/x-icon',
|
'.jpe':'image/jpeg',
|
'.jpeg':'image/jpeg',
|
'.jpg':'application/x-jpg',
|
'.png':'application/x-png',
|
'.gif':'image/gif',
|
'.bin':'application/octet-stream',
|
'.*':'application/octet-stream'
|
}
|
|
def GetHttpContentType(strType):
|
return FileTypeDict[strType]
|
|
|
|
## ±àÂë
|
# @param srcEncoding ±àÂë¸ñʽ
|
# @param input ×Ö·û´®
|
# @return None
|
def EncodingToUnicode(srcEncoding, msg):
|
try:
|
result = unicode(msg, srcEncoding) #translate to utf-8
|
except:
|
return "EncodingToUnicode error"
|
return result
|
|
|
## ±àÂë
|
# @param srcEncoding ±àÂë¸ñʽ
|
# @param input ×Ö·û´®
|
# @return None
|
def UnicodeToEncoding(dstEncoding, msg):
|
try:
|
result = msg.encode(dstEncoding)
|
except:
|
return "UnicodeToEncoding error"
|
return result
|
