whatap-python 2.1.0__py3-none-any.whl

whatap/util/escape_literal_sql.py

@@ -0,0 +1,233 @@
+class STAT(object):
+    NORMAL = 0
+    COMMENT = 1
+    ALPHABET = 2
+    NUMBER = 3
+    QUTATION = 4
+    COLON = 5
+
+
+class EscapeLiteralSQL(object):
+    def __init__(self, sql=''):
+        self.substitute = '#'
+        self.substitute_num = '#'
+        self.substitute_str_mode = False
+        self.pos = 0
+        self.chars = list(sql)
+        self.length = len(self.chars)
+        self.parsedSql = ''
+        self.param = ''
+        self.status = -1
+        self.sqlType = 0
+    
+    def setSubstitute(self, chr):
+        self.substitute = chr
+        
+        if self.substitute_str_mode:
+            self.substitute_num = '"' + chr + '"'
+        else:
+            self.substitute_num = self.substitute
+        
+        return self
+    
+    def setSubstituteStringMode(self, b):
+        if self.substitute_str_mode == b:
+            return self
+        
+        self.substitute_str_mode = b
+        if self.substitute_str_mode:
+            self.substitute_num = '"' + self.substitute + '"'
+        else:
+            self.substitute_num = self.substitute
+        return self
+    
+    def process(self):
+        self.status = STAT.NORMAL
+        
+        for c in self.chars:
+            if c in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']:
+                self._number()
+            elif c == ':':
+                self._colon()
+            elif c == '.':
+                self._dot()
+            elif c == '-':
+                self._minus()
+            elif c == '/':
+                self._slash()
+            elif c == '*':
+                self._astar()
+            elif c in ['\'', '\"']:
+                self._quotation()
+            else:
+                self._others()
+                
+            self.pos += 1
+        
+        return self
+    
+    def _others(self):
+        status = self.status
+        
+        if status == STAT.COMMENT:
+            self.parsedSql += self.chars[self.pos]
+        elif status == STAT.ALPHABET:
+            self.parsedSql += self.chars[self.pos]
+            if not self.isProgLetter(self.chars[self.pos]):
+                self.status = STAT.NORMAL
+        elif status == STAT.NUMBER:
+            self.parsedSql += self.chars[self.pos]
+            self.status = STAT.NORMAL
+        elif status == STAT.QUTATION:
+            self.param += self.chars[self.pos]
+        else:
+            if self.isProgLetter(self.chars[self.pos]):
+                self.status = STAT.ALPHABET
+                if not self.sqlType:
+                    self.define_crud()
+            else:
+                self.status = STAT.NORMAL
+            self.parsedSql += self.chars[self.pos]
+    
+    def isProgLetter(self, ch):
+        return isLetter(ch) or ch == '_'
+    
+    def define_crud(self):
+        self.sqlType = self.chars[self.pos].upper()
+        
+        if self.sqlType not in ['S', 'D', 'U', 'I']:
+            self.sqlType = '*'
+    
+    def _colon(self):
+        status = self.status
+        
+        if status == STAT.COMMENT:
+            self.parsedSql += self.chars[self.pos]
+        elif status == STAT.QUTATION:
+            self.param += self.chars[self.pos]
+        else:
+            self.parsedSql += self.chars[self.pos]
+            self.status = STAT.COLON
+    
+    def _quotation(self):
+        status = self.status
+        
+        if status == STAT.NORMAL:
+            if len(self.param) > 0:
+                self.param += ','
+            self.param += self.chars[self.pos]
+            self.status = STAT.QUTATION
+        elif status == STAT.COMMENT:
+            self.parsedSql += self.chars[self.pos]
+        elif status == STAT.ALPHABET:
+            self.parsedSql += self.chars[self.pos]
+            self.status = STAT.QUTATION
+        elif status == STAT.NUMBER:
+            self.parsedSql += self.chars[self.pos]
+            self.status = STAT.QUTATION
+        elif status == STAT.QUTATION:
+            self.param += '"'
+            self.parsedSql = self.parsedSql + '\'' + self.substitute + '\''
+            self.status = STAT.NORMAL
+    
+    def _astar(self):
+        status = self.status
+        
+        if status == STAT.COMMENT:
+            self.parsedSql += self.chars[self.pos]
+            if self.getNext(self.pos) == '/':
+                self.parsedSql += '/'
+                self.pos += 1
+                self.status = STAT.NORMAL
+        elif status == STAT.QUTATION:
+            self.param += self.chars[self.pos]
+        else:
+            self.parsedSql += self.chars[self.pos]
+            self.status = STAT.NORMAL
+    
+    def _slash(self):
+        
+        status = self.status
+        
+        if status == STAT.COMMENT:
+            self.parsedSql += self.chars[self.pos]
+        elif status == STAT.QUTATION:
+            self.param += self.chars[self.pos]
+        else:
+            if self.getNext(self.pos) == '*':
+                self.pos += 1
+                self.parsedSql += '/*'
+                self.status = STAT.COMMENT
+    
+    def _minus(self):
+        
+        status = self.status
+        
+        if status == STAT.COMMENT:
+            self.parsedSql += self.chars[self.pos]
+        elif status == STAT.QUTATION:
+            self.param += self.chars[self.pos]
+        else:
+            if self.getNext(self.pos) == '-':
+                self.parsedSql += self.chars[self.pos]
+                while self.chars[self.pos] != '\n':
+                    self.pos += 1
+                    if self.pos < self.length:
+                        self.parsedSql += self.chars[self.pos]
+                    else:
+                        break
+            else:
+                self.parsedSql += self.chars[self.pos]
+            self.status = STAT.NORMAL
+    
+    def _dot(self):
+        
+        status = self.status
+        
+        if status == STAT.NORMAL:
+            self.parsedSql += self.chars[self.pos]
+        elif status == STAT.COMMENT:
+            self.parsedSql += self.chars[self.pos]
+        elif status == STAT.ALPHABET:
+            self.parsedSql += self.chars[self.pos]
+            self.status = STAT.NORMAL
+        elif status == STAT.NUMBER:
+            self.param += self.chars[self.pos]
+        elif status == STAT.QUTATION:
+            self.param += self.chars[self.pos]
+    
+    def _number(self):
+        
+        status = self.status
+        
+        if status == STAT.NORMAL:
+            if len(self.param):
+                self.param += ','
+            self.param += self.chars[self.pos]
+            self.parsedSql += self.substitute_num
+            self.status = STAT.NUMBER
+        elif status in [STAT.COMMENT, STAT.COLON, STAT.ALPHABET]:
+            self.parsedSql += self.chars[self.pos]
+        elif status in [STAT.NUMBER, STAT.QUTATION]:
+            self.param += self.chars[self.pos]
+    
+    def getNext(self, x):
+        return self.chars[x + 1] if x < self.length else 0
+    
+    def getParsedSql(self):
+        return self.parsedSql
+    
+    def getParameter(self):
+        return self.param
+
+
+ASCII_a = 97
+ASCII_z = 122
+ASCII_A = 65
+ASCII_Z = 90
+
+
+def isLetter(ch):
+    str = ord(ch[0])
+    return ((str >= ASCII_a) and (str <= ASCII_z)) or (
+        (str >= ASCII_A) and (str <= ASCII_Z))

whatap/util/frame_util.py

@@ -0,0 +1,20 @@
+"""greenlet/gevent 환경 지원 유틸리티"""
+import sys
+import threading
+
+
+def get_current_frame(ctx=None):
+    """현재 실행 frame 가져오기"""
+    return sys._getframe()
+
+
+def set_greenlet_info(ctx):
+    """greenlet 환경이면 context에 greenlet 정보 저장"""
+    greenlet_module = sys.modules.get('greenlet')
+    if greenlet_module:
+        current_greenlet = greenlet_module.getcurrent()
+        if current_greenlet is not None:
+            ctx.greenlet = current_greenlet
+            ctx.greenlet_id = id(current_greenlet)
+            return True
+    return False

whatap/util/hash_util.py

@@ -0,0 +1,103 @@
+import io
+from operator import xor
+
+_TABLE = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+          0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e,
+          0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064,
+          0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551,
+          0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f,
+          0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+          0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa,
+          0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf,
+          0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5,
+          0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2,
+          0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+          0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5,
+          0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb,
+          0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8,
+          0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6,
+          0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+          0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541,
+          0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846,
+          0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c,
+          0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409,
+          0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+          0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c,
+          0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12,
+          0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27,
+          0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d,
+          0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+          0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8,
+          0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd,
+          0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3,
+          0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0,
+          0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+          0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b,
+          0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9,
+          0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae,
+          0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4,
+          0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+          0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff,
+          0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354,
+          0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a,
+          0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f,
+          0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+          0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02,
+          0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d]
+
+
+def hex_to_int(hex):
+    hex = format(hex, 'x')
+    if len(hex) % 2 != 0:
+        hex = "0" + hex
+
+    num = int(str(hex), 16)
+    maxVal = int(pow(2, len(str(hex)) / 2 * 8))
+    if num > maxVal / 2 - 1:
+        num = num - maxVal
+
+    return num
+
+
+for i, hex in enumerate(_TABLE):
+    _TABLE[i] = hex_to_int(hex)
+
+
+class HashUtil(object):
+    @classmethod
+    def crc32(cls, s):
+        buf = io.BytesIO(len(s))
+        buf.write(s, 'utf-8')
+        crc = 0
+        crc = crc ^ (-1)
+        for b in buf:
+            crc = _TABLE[(crc ^ b) & 0xff] ^ (crc >> 8)
+        return crc ^ (-1)
+
+    @classmethod
+    def hashFromString(cls, s):
+        buffer = s if isinstance(s, str) else ''
+        return cls.hash(bytearray(buffer, 'utf-8'))
+
+    @classmethod
+    def toInt(cls, buf):
+        ch1 = buf[0] & 255
+        ch2 = buf[1] & 255
+        ch3 = buf[2] & 255
+        ch4 = buf[3] & 255
+        return (ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0)
+
+    @classmethod
+    def hash(cls, bytes):
+        crc = -1
+        if bytes:
+            l = list(bytes)
+
+            if l[0] == '-':
+                l.remove('-')
+                l[0] = int(l[0]) * -1
+
+            for b in l:
+                crc = ((crc % 0x100000000) >> 8) ^ _TABLE[(crc ^ int(b)) & 255]
+                crc = crc
+        return ~crc

whatap/util/hexa32.py

@@ -0,0 +1,66 @@
+class Hexa32(object):
+    PLUS = 'x'
+    MINUS = 'z'
+    min = "z8000000000000"
+    
+    @classmethod
+    def toString32(cls, num):
+        minus = num < 0
+        if minus:
+            if num == cls.MINUS:
+                return cls.min
+            return cls.MINUS + encode(-num)
+        else:
+            if num < 10:
+                return encode(num)
+            else:
+                return cls.PLUS + encode(num)
+    
+    @classmethod
+    def toLong32(cls, str):
+        if not str or not len(str):
+            return 0
+        
+        first_str = str[0]
+        if first_str == cls.MINUS:
+            return -1 * decode(str[1:])
+        elif first_str == cls.PLUS:
+            return decode(str[1:])
+        else:
+            return decode(str)
+
+
+CHARS = "0123456789abcdefghijklmnopqrstuvwxyz"
+
+
+def encode(num):
+    encoded_chars = []
+    while num > 0:
+        remainder = num % 32
+        num //= 32
+        encoded_chars.append(CHARS[remainder])
+    return ''.join(encoded_chars[::-1])
+
+
+def decode(string):
+    num = 0
+    for power, char in enumerate(string[::-1]):
+        try:
+            val = CHARS.index(char)
+        except ValueError:
+            raise ValueError('invalid character: %s' % char)
+        num += 32 ** power * val
+    return num
+
+
+if __name__=='__main__':
+
+    n=-7329592890664812990
+    s = 'z6bdvhspq4s0du'
+
+
+    print(Hexa32.toString32(n))
+    print(Hexa32.toLong32(s))
+    
+    print(s==Hexa32.toString32(n))
+    print(n == Hexa32.toLong32(s))

whatap/util/int_set.py

@@ -0,0 +1,199 @@
+import threading
+import whatap.io.data_outputx as data_outputx
+from io import StringIO
+
+class IntSetry(object):
+	def __init__(self, key=0, next= None):
+		self.key = key
+		self.next = next
+
+	def clone(self):
+		return  IntSetry(self.key, None if self.next is None else next.clone())
+
+	def getKey(self):
+		return self.key
+
+	def equals(self, o):
+		if not instance(o,IntSetry):
+			return False
+
+		return self.key == o.getKey()
+
+	def hashCode(self):
+		return self.key
+
+	def toString(self):
+		return str(key)
+
+class Enumer(object):
+	def __init__(self, table):
+		self.table = table
+		self.index = len(table)
+		self.entry = None
+		self.lastReturned = None
+
+	def hasMoreElements(self):
+		while self.entry is None and self.index > 0:
+			self.index -= 1
+			self.entry = self.table[self.index]
+
+		return self.entry is not None
+
+	def nextInt(self):
+		while self.entry is None and self.index > 0:
+			self.index -= 1
+			self.entry = self.table[self.index]
+		if self.entry is not None:
+			e = self.lastReturned = self.entry
+			self.entry = e.next
+			return e.key
+		raise Exception("no more next")
+
+
+class EmptyEnumer(object):
+	def hasMoreElements(self):
+		return 0
+
+	def nextInt(self):
+		return False
+
+class IntSet(object):
+	emptyEnumer = EmptyEnumer()
+
+	def __init__(self, initCapacity = int(101), loadFactor = float(0.75)):
+		self.count = 0
+		if initCapacity < 0:
+			raise Exception("Capacity Error: " + initCapacity)
+		if loadFactor <= 0:
+			raise Exception("Load Count Error: " + loadFactor)
+		if initCapacity == 0:
+			initCapacity = 1
+		self.loadFactor = loadFactor;
+		self.table = [None]*initCapacity
+		self.threshold = int(initCapacity * loadFactor)
+
+		self.lock = threading.Lock()
+
+	def size(self):
+		return self.count
+
+	def values(self):
+		try:
+			self.lock.acquire()
+			return Enumer(self.table)
+		finally:
+			self.lock.release()
+
+	def contains(self, key):
+		buk = self.table
+		index = (key & data_outputx.INT_MAX_VALUE) % len(buk)
+		e = buk[index]
+		while e is not None:
+			if e.key == key:
+				return True
+			e = e.next
+
+		return False
+
+	def get(self, key):
+		buk = self.table
+		index = (key & data_outputx.INT_MAX_VALUE) % len(buk)
+
+		e = buk[index]
+		while e is not None:
+			if e.key == key:
+				return e.key
+
+		return 0
+
+	def rehash(self):
+		oldCapacity = len(self.table)
+		oldMap = self.table
+		newCapacity = oldCapacity * 2 + 1
+		newMap = [None]*newCapacity
+		self.threshold = int(newCapacity * loadFactor)
+		self.table = newMap
+
+		for i in range(oldCapacity, 1, -1):
+			old = oldMap[i]
+			while old is not None:
+				e = old
+				old = old.next
+				index = (e.key & data_outputx.INT_MAX_VALUE) % newCapacity
+				e.next = newMap[index]
+				newMap[index] = e
+
+	def putAll(self, values):
+		if not values :
+			return
+		for v in values:
+			self.put(v)
+
+	def put(self, value):
+		buk = self.table
+		index = (value & data_outputx.INT_MAX_VALUE) % len(buk)
+		e = buk[index]
+		while  e is not None:
+			if e.key == value:
+				return False
+			e = e.next
+		if self.count >= self.threshold:
+			self.rehash()
+			buk = self.table
+			index = (value & Integer.MAX_VALUE) % len(buk)
+
+		e = IntSetry(value, buk[index])
+		buk[index] = e
+		self.count +=1
+		return True
+
+	def remove(self, key):
+		buk = self.table
+		index = (key & data_outputx.INT_MAX_VALUE) % len(buk)
+		e = buk[index]
+		prev = None
+		while e is not None:
+			if e.key == key:
+				if prev is not None:
+					prev.next = e.next
+				else:
+					buk[index] = e.next
+				self.count-=1
+				return key
+			prev = e, e = e.next
+
+		return 0
+
+	def clear(self):
+		buk = table
+		for index in range(len(buk), 0, -1):
+			buk[index] = None
+		self.count = 0
+
+	def toString(self):
+		max = self.size() - 1
+		buf = StringIO()
+		it = this.values()
+		buf.write("{")
+		for i in range(max):
+			key = it.nextInt()
+			buf.write(str(key))
+			if i < max:
+				buf.write(", ")
+		buf.write("}")
+
+		return buf.getvalue()
+
+	def toArray(self):
+		_keys = int[self.size()]
+		en = self.values()
+		for i in range(len(_keys)):
+			_keys[i] = en.nextInt()
+		return _keys
+
+	def isExistElseAdd(self, value):
+		return self.put(value) == False
+
+	def putStrHash(self, s):
+		if s is not None:
+			self.put(hash(s))

whatap/util/ip_util.py

@@ -0,0 +1,63 @@
+from whatap.io.data_inputx import DataInputX
+from whatap.io.data_outputx import DataOutputX
+
+
+class IPUtil(object):
+    empty = bytearray([0, 0, 0, 0])
+
+    @classmethod
+    def toString(cls, ip):
+        if isinstance(ip, int):
+            return cls.toString(DataOutputX.toBytes(ip))
+        elif isinstance(ip, bytes) or isinstance(ip, bytearray):
+            try:
+                to_str = '{0}.{1}.{2}.{3}'.format(ip[0] & 0xff, ip[1] & 0xff,
+                                                  ip[2] & 0xff, ip[3] & 0xff)
+                return to_str
+            except Exception:
+                return '0.0.0.0'
+
+    @classmethod
+    def toBytes(cls, ip):
+        if isinstance(ip, int):
+            return DataOutputX.toBytes(ip)
+        elif isinstance(ip, str):
+            # if not ip:
+            #     return cls.empty
+
+            try:
+                ss = ip.split('.')
+                ss_ln = len(ss)
+                if ss_ln != 4:
+                    return cls.empty
+
+                result = bytearray(ss_ln)
+                for i in range(ss_ln):
+                    s = int(ss[i])
+                    if s < 0 or s > 0xff:
+                        return cls.empty
+
+                    result[i] = s & 0xff
+                return result
+            except Exception as e:
+                import traceback
+                traceback.print_stack()
+                return cls.empty
+
+    @classmethod
+    def toInt(cls, ip):
+        if isinstance(ip, bytes):
+            if cls.isOK(ip):
+                return DataInputX.toInt(ip, 0)
+            else:
+                return 0
+        elif isinstance(ip, str):
+            return DataInputX.toInt(cls.toBytes(ip), 0)
+
+    @classmethod
+    def isOK(cls, ip):
+        return ip is not None and len(ip) == 4
+
+    @classmethod
+    def isNotLocal(cls, ip):
+        return cls.isOK(ip) and (ip[0] & 0xff) != 127

whatap/util/keygen.py

@@ -0,0 +1,11 @@
+from whatap.util.date_util import DateUtil
+import random
+try:
+    random.seed(DateUtil.nowSystem())
+except:
+    pass
+
+class KeyGen(object):
+    @classmethod
+    def next(cls):
+        return int(random.random()*0x7fffffff)