whatap-python 2.1.0__py3-none-any.whl

whatap/util/linked_list.py

@@ -0,0 +1,113 @@
+class LinkedList(object):
+    def __init__(self):
+        self._length = 0
+        self._head = None
+        self._current = None
+        self._tail = None
+
+    def size(self):
+        return self._length
+
+    def add(self, data):
+        node = {
+            'data': data,
+            'next': None,
+            'prev': None
+        }
+        if not self._head:
+            self._head = node
+            self._current = {'next': node}
+        else:
+            self._tail['next'] = node
+            node['prev'] = self._tail
+
+        self._tail = node
+        self._length += 1
+
+    def get(self, index):
+        if index > -1 and index < self._length:
+            current = self._head, i = 1
+            while i < index:
+                current = current['next']
+                i += 1
+            return current['data']
+
+        else:
+            return None
+
+    def remove(self, index):
+        if index > -1 and index < self._length:
+            current = self._head, previous, i = 0
+            if index == 0:
+                self._head = current['next']
+            else:
+                i = 1
+                while i < index:
+                    previous = current
+                    current = current['next']
+                previous['next'] = current['next']
+            self._length -= 1
+            return current['data']
+        else:
+            return None
+
+    def getFirst(self):
+        return self._head['data']
+
+    def getValue(self, ent):
+        if not ent:
+            return None
+        return ent['data']
+
+    def next(self):
+        if self._current['next']:
+            self._current = self._current['next']
+            return self._current['data']
+        else:
+            return None
+
+    def hasNext(self):
+        if self._current and self._current['next']:
+            return True
+        else:
+            return False
+
+    def removeFirst(self):
+        target = self._head
+        if self._head:
+            if self._head == self._current['next']:
+                self._current = None
+            if self._head['next']:
+                self._head = self._head['next']
+                self._current = self._head
+                self._head['prev'] = None
+            else:
+                self._head = None
+            self._length -= 1
+        return target['data']
+
+    def removeEntry(self, current):
+        if not current:
+            return
+
+        if self._head == current:
+            self._head = current['next']
+
+        else:
+            previous = current
+            current = current['next']
+            previous['next'] = current['next']
+        self._length -= 1
+
+        # def toString(self):
+        #     str = ''
+        #     e = list.getFirst()
+        #     if not e:
+        #         return '[]'
+        #     else:
+        #         str = '[' + e['data']
+        #         e = list.getNext(e)
+        #     while e:
+        #         str += ',' + e['data']
+        #         e = list.getNext(e)
+        #     return str + ']'

whatap/util/linked_map.py

@@ -0,0 +1,359 @@
+from whatap.util.hash_util import HashUtil
+
+DEFAULT_CAPACITY = 101
+DEFAULT_LOAD_FACTOR = 0.75
+TYPE = {
+    'KEYS': 0,
+    'VALUES': 1,
+    'ENTRIES': 2
+}
+MODE = {
+    'FORCE_FIRST': 0,
+    'FORCE_LAST': 1,
+    'FIRST': 2,
+    'LAST': 3
+}
+
+
+class LinkedEntry(object):
+    def __init__(self, key, value, next):
+        self.key = key
+        self.value = value
+        self.next = next
+        self.link_next = None
+        self.link_prev = None
+
+    def getKey(self):
+        return self.key
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        oldValue = self.value
+        self.value = value
+        return oldValue
+
+    def hashCode(self):
+        return HashUtil.hashFromString(self.key)
+
+    def toString(self):
+        return self.key + "=" + self.value
+
+
+class Enumer():
+    def __init__(self, map, type):
+        self.map = map
+        self.entry = map.header.link_next
+        self.lastEnt = None
+        self.type = type if type else TYPE['ENTRIES']
+
+    def hasMoreElements(self):
+        return self.map.header is not self.entry and self.entry is not None
+
+    def nextElement(self):
+        if self.hasMoreElements():
+            e = self.lastEnt = self.entry
+            self.entry = e.link_next
+            if self.type == TYPE['KEYS']:
+                return e.key
+            elif self.type == TYPE['VALUES']:
+                return e.value
+            else:
+                return e
+        else:
+            return
+
+
+class LinkedMap(object):
+    MODE = MODE
+
+    def __init__(self, initCapacity=None, loadFactor=None):
+        self.initCapacity = initCapacity if initCapacity else DEFAULT_CAPACITY
+        self.loadFactor = loadFactor if loadFactor else DEFAULT_LOAD_FACTOR
+        self.threshold = int(self.initCapacity * self.loadFactor)
+
+        self.table = [None for _ in range(self.initCapacity)]
+        self.header = LinkedEntry(None, None, None)
+        self.header.link_next = self.header.link_prev = self.header
+        self.count = 0
+        self.max = 0
+
+    def size(self):
+        return self.count
+
+    def keys(self):
+        return Enumer(self, TYPE['KEYS'])
+
+    def values(self):
+        return Enumer(self, TYPE['VALUES'])
+
+    def entries(self):
+        return Enumer(self, TYPE['ENTRIES'])
+
+    def containsKey(self, key):
+        if key is None:
+            return False
+
+        tab = self.table
+        index = self.hash(key) % len(tab)
+        e = tab[index]
+
+        while True:
+            if not e:
+                return False
+
+            if e.key == key:
+                return True
+            e = e.next
+
+    def get(self, key):
+        if key is None:
+            return None
+
+        tab = self.table
+        index = self.hash(key) % len(tab)
+        e = tab[index]
+
+        while True:
+            if not e:
+                return None
+
+            if e.key == key:
+                return e.value
+            e = e.next
+
+    def getLastValue(self):
+        if self.isEmpty():
+            return None
+        return self.header.link_prev.value
+
+    def hash(self, key):
+        if not key:
+            return 0
+        return HashUtil.hashFromString(str(key)) & 0x7fffffff
+
+    def rehash(self):
+        oldCapacity = len(self.table)
+        oldMap = self.table
+        newCapacity = oldCapacity * 2 + 1
+        newMap = [None for _ in range(newCapacity)]
+        self.threshold = int(newCapacity * self.loadFactor)
+        self.table = newMap
+
+        for i in range(oldCapacity -1, -1, -1):
+            old = oldMap[i]
+            while True:
+                if not old:
+                    break
+
+                e = old
+                old = old.next
+                key = e.key
+                index = self.hash(key) % newCapacity
+                e.next = newMap[index]
+                newMap[index] = e
+
+    def isEmpty(self):
+        return self.size() == 0
+
+    def setMax(self, max):
+        self.max = max
+        return self
+
+    def isFull(self):
+        return self.max > 0 and self.max <= self.count
+
+    def put(self, key, value):
+        return self._put(key, value, MODE['LAST'])
+
+    def putLast(self, key, value):
+        return self._put(key, value, MODE['FORCE_LAST'])
+
+    def putFirst(self, key, value):
+        return self._put(key, value, MODE['FORCE_FIRST'])
+
+    def _put(self, key, value, m, noover=False):
+        if noover and self.max > 0 and self.size() > self.max:
+            return None
+
+        tab = self.table
+        index = self.hash(key) % len(tab)
+        e = tab[index]
+
+        while True:
+            if not e:
+                break
+
+            if e.key == key:
+                old = e.value
+                e.value = value
+                if m == MODE['FORCE_FIRST']:
+                    if self.header.link_next != e:
+                        self.unchain(e)
+                        self.chain(self.header, self.header.link_next, e)
+                elif m == MODE['FORCE_LAST']:
+                    if self.header.link_prev != e:
+                        self.unchain(e)
+                        self.chain(self.header.link_prev, self.header, e)
+                return old
+
+            e = e.next
+
+        if self.max > 0:
+            if m == MODE['FORCE_FIRST'] or m == MODE['FIRST']:
+                while self.count >= self.max:
+                    k = self.header.link_prev.key
+                    v = self.remove(k)
+                    self.overflowed(k, v)
+            elif m == MODE['FORCE_LAST'] or m == MODE['LAST']:
+                while self.count >= self.max:
+                    k = self.header.link_next.key
+                    v = self.remove(k)
+                    self.overflowed(k, v)
+
+        if self.count >= self.threshold:
+            self.rehash()
+            tab = self.table
+            index = self.hash(key) % len(tab)
+
+        e = LinkedEntry(key, value, tab[index])
+        tab[index] = e
+
+        if m == MODE['FORCE_FIRST'] or m == MODE['FIRST']:
+            self.chain(self.header, self.header.link_next, e)
+        elif m == MODE['FORCE_LAST'] or m == MODE['LAST']:
+            self.chain(self.header.link_prev, self.header, e)
+
+        self.count += 1
+        return None
+
+    def overflowed(self, key, value):
+        return
+
+    def create(self, key):
+        return
+
+    def intern(self, key):
+        return self._intern(key, MODE['LAST'])
+
+    def _intern(self, key, m):
+        tab = self.table
+        index = self.hash(key) % len(tab)
+        e = tab[index]
+
+        while True:
+            if not e:
+                break
+
+            if e.key == key:
+                old = e.value
+
+                if m == MODE['FORCE_FIRST']:
+                    if self.header.link_next != e:
+                        self.unchain(e)
+                        self.chain(self.header, self.header.link_next, e)
+                elif m == MODE['FORCE_LAST']:
+                    if self.header.link_prev != e:
+                        self.unchain(e)
+                        self.chain(self.header.link_prev, self.header, e)
+                return old
+            e = e.next
+
+        value = self.create(self, key)
+        if not value:
+            return None
+
+        if self.max > 0:
+            if m == MODE['FORCE_FIRST'] or m == MODE['FIRST']:
+                while self.count >= self.max:
+                    k = self.header.link_prev.key
+                    v = self.remove(k)
+                    self.overflowed(k, v)
+            elif m == MODE['FORCE_LAST'] or m == MODE['LAST']:
+                while self.count >= self.max:
+                    k = self.header.link_next.key
+                    v = self.remove(k)
+                    self.overflowed(k, v)
+
+        if self.count >= self.threshold:
+            self.rehash()
+            tab = self.table
+            index = self.hash(key) % len(tab)
+
+        e = LinkedEntry(key, value, tab[index])
+        tab[index] = e
+
+        if m == MODE['FORCE_FIRST'] or m == MODE['FIRST']:
+            self.chain(self.header, self.header.link_next, e)
+        elif m == MODE['FORCE_LAST'] or m == MODE['LAST']:
+            self.chain(self.header.link_prev, self.header, e)
+
+        self.count += 1
+        return value
+
+    def remove(self, key):
+        if key is None:
+            return None
+
+        tab = self.table
+        index = self.hash(key) % len(tab)
+        e = tab[index]
+        prev = None
+
+        while True:
+            if not e:
+                return None
+
+            if e.key == key:
+                if prev:
+                    prev.next = e.next
+                else:
+                    tab[index] = e.next
+
+                self.count -= 1
+                oldValue = e.value
+                e.value = None
+                self.unchain(e)
+                return oldValue
+
+            prev = e
+            e = e.next
+        return None
+
+    def removeFirst(self):
+        if self.isEmpty():
+            return None
+        return self.remove(self.header.link_next.key)
+
+    def removeLast(self):
+        if self.isEmpty():
+            return None
+        return self.remove(self.header.link_prev.key)
+
+    def clear(self):
+        tab = self.table
+        for i, t in enumerate(tab):
+            tab[i] = None
+        self.header.link_next = self.header.link_prev = self.header
+        self.count = 0
+
+    def chain(self, link_prev, link_next, e):
+        e.link_prev = link_prev
+        e.link_next = link_next
+        link_prev.link_next = e
+        link_next.link_prev = e
+
+    def unchain(self, e):
+        e.link_prev.link_next = e.link_next
+        e.link_next.link_prev = e.link_prev
+        e.link_prev = None
+        e.link_next = None
+
+    def putAll(self, other):
+        if not other or not isinstance(other, LinkedMap):
+            return
+        it = other.entries()
+        while it.hasMoreElements():
+            e = it.nextElement()
+            self.put(e.getKey(), e.getValue())

whatap/util/metering_util.py

@@ -0,0 +1,103 @@
+from whatap.util.date_util import DateUtil
+
+
+class MeteringUtil(object):
+    def MeteringUtil(self, timeUnit=1000, bucketSize=301,
+                     create=None, clear=None):
+        self.TIME_UNIT = timeUnit
+        self.BUCKET_SIZE = bucketSize
+        self._time_ = self.getTime()
+        self._pos_ = self._time_ % self.BUCKET_SIZE
+        self.table = [self.create() for _ in range(bucketSize)]
+
+        self.create = create
+        self.clear = clear
+
+    def create(self):
+        return self.create
+
+    def clear(self):
+        return self.clear
+
+    def getLastBucket(self):
+        pos = self.getPosition()
+        return self.table[self.stepback(pos)]
+
+    def getLastTwoBucket(self):
+        pos = self.stepback(self.getPosition())
+        t1 = self.table[pos]
+        pos = self.stepback(pos)
+        t2 = self.table[pos]
+        if not t1:
+            return None
+
+        return [t1, t2]
+
+    def getCurrentBucket(self, time=None):
+        if not time:
+            pos = self.getPosition()
+            return self.table[pos]
+        else:
+            pos = self.getPosition(time)
+            if pos >= 0:
+                return self.table[pos]
+            else:
+                return None
+
+    def getPosition(self, time=None):
+        curTime = self.getTime()
+        if curTime != self._time_:
+            i = 0
+            while (curTime - self._time_) and i < self.BUCKET_SIZE:
+                _pos_ = 0 if self._pos_ + 1 > self.BUCKET_SIZE - 1 \
+                    else self._pos_ + 1
+                self.clear(self.table[_pos_])
+            i += 1
+
+            self._time_ = curTime
+            self._pos_ = int(self._time_ % self.BUCKET_SIZE)
+
+        if not time:
+            return self._pos_
+        else:
+            theTime = time / self.TIME_UNIT
+            if theTime > curTime or theTime < curTime - self.BUCKET_SIZE + 2:
+                return -1
+        return int(theTime % self.BUCKET_SIZE)
+
+    def check(self, period):
+        if period >= self.BUCKET_SIZE:
+            period = self.BUCKET_SIZE - 1
+        return period
+
+    def stepback(self, pos):
+        if not pos:
+            pos = self.BUCKET_SIZE - 1
+        else:
+            pos -= 1
+        return pos
+
+    def search(self, period, h=None, skip=None):
+        period = self.check(period)
+        pos = self.getPosition()
+
+        if not h and not skip:
+            out = []
+            for i in range(period):
+                out.append(self.table[pos])
+            return out
+        else:
+            if skip:
+                for _ in skip:
+                    pos = self.stepback(pos)
+
+            i = 0
+            while i < period:
+                h.process(self.table[pos])
+                pos = self.stepback(pos)
+                i += 1
+
+            return period
+
+    def getTime(self):
+        return DateUtil.currentTime() / self.TIME_UNIT

whatap/util/request_double_queue.py

@@ -0,0 +1,68 @@
+import time
+
+from whatap import logging
+from whatap.util.linked_list import LinkedList
+
+
+class RequestDoubleQueue(object):
+    def __init__(self, capacity1, capacity2):
+        self.capacity1 = capacity1
+        self.capacity2 = capacity2
+        self.queue1 = LinkedList()
+        self.queue2 = LinkedList()
+
+    def get(self):
+        while self.queue1.size() <= 0 and self.queue2.size() <= 0:
+            try:
+                time.sleep(0.5)
+            except Exception as e:
+                logging.debug(e, extra={'id': 'WA510'}, exc_info=True)
+
+        if self.queue1.size() > 0:
+            return self.queue1.removeFirst()
+        elif self.queue2.size() > 0:
+            return self.queue2.removeFirst()
+
+        return None
+
+    def hasNext(self):
+        if self.queue1.hasNext() or self.queue2.hasNext():
+            return True
+        return False
+
+    def putForce1(self, o):
+        return self.putForce(self.queue1, self.capacity1, o)
+
+    def putForce2(self, o):
+        return self.putForce(self.queue2, self.capacity2, o)
+
+    def putForce(self, q, sz, o):
+        if sz <= 0 or q.size() < self.capacity1:
+            q.add(o)
+            return True
+        else:
+            while q.size() >= sz:
+                v = q.removeFirst()
+                self.overflowed(v)
+            q.add(o)
+            return False
+
+    def put1(self, o):
+        return self.put(self.queue1, self.capacity1, o)
+
+    def put2(self, o):
+        return self.put(self.queue1, self.capacity2, o)
+
+    def put(self, queue, capacity, o):
+        if capacity <= 0 or queue.size() < capacity:
+            queue.add(o)
+            return True
+        else:
+            self.failed(o)
+            return False
+
+    def failed(self, v):
+        return
+
+    def overflowed(self, v):
+        return

whatap/util/request_queue.py

@@ -0,0 +1,60 @@
+import time
+
+from whatap import logging
+from whatap.util.date_util import DateUtil
+from whatap.util.linked_list import LinkedList
+
+
+class RequestQueue(object):
+    def __init__(self, capacity):
+        self.capacity = capacity
+        self.queue = LinkedList()
+
+    def get(self, timeout=None):
+        if not timeout:
+            while self.queue.size() <= 0:
+                try:
+                    time.sleep(0.5)
+                except Exception as e:
+                    logging.debug(e, extra={'id': 'WA520'}, exc_info=True)
+            return self.queue.removeFirst()
+        else:
+            if self.queue.size() > 0:
+                return self.queue.removeFirst()
+
+            timeto = DateUtil.currentTime() + timeout
+            while not self.queue.size():
+                try:
+                    if timeout > 0:
+                        time.sleep(5)
+
+                except Exception as e:
+                    logging.debug(e, extra={'id': 'WA521'}, exc_info=True)
+
+                if timeto - DateUtil.currentTime() <= 0:
+                    break
+
+            if self.queue.size() > 0:
+                return self.queue.removeFirst()
+
+            return None
+
+    def put(self, o):
+        if self.capacity <= 0 or self.queue.size() < self.capacity:
+            self.queue.add(o)
+            return True
+        else:
+            self.failed(o)
+            return False
+
+    def size(self):
+        return self.queue.size()
+
+    def clear(self):
+        self.queue = LinkedList()
+
+    def failed(self, v):
+        return
+
+    def overflowed(self, v):
+        return