whatap-python 2.1.0__py3-none-any.whl

whatap/value/list_value.py

@@ -0,0 +1,105 @@
+from whatap.value.boolean_value import BooleanValue
+from whatap.value.decimal_value import DecimalValue
+from whatap.value.double_value import DoubleValue
+from whatap.value.float_value import FloatValue
+from whatap.value.number_value import NumberValue
+from whatap.value.text_value import TextValue
+
+from whatap.value.value import Value
+from whatap.value.value_enum import ValueEnum
+
+
+class ListValue(Value):
+    def __init__(self, valueList=None):
+        super(ListValue, self).__init__()
+        self.valueList = valueList if isinstance(valueList, list) else []
+
+    def getBoolean(self, i):
+        v = self.valueList[i]
+        if isinstance(v, BooleanValue):
+            return v.value
+        return False
+
+    def getDouble(self, i):
+        v = self.valueList[i]
+        if isinstance(v, NumberValue):
+            return v.doubleValue()
+        return 0.0
+
+    def getLong(self, i):
+        v = self.valueList[i]
+        if isinstance(v, NumberValue):
+            return v.longValue()
+        return 0
+
+    def getInt(self, i):
+        v = self.valueList[i]
+        if isinstance(v, NumberValue):
+            return v.intValue()
+        return 0
+
+    def getString(self, i):
+        v = self.valueList[i]
+        if isinstance(v, TextValue):
+            return v.value
+        if not v:
+            return None
+        return v
+
+    def set(self, i, value):
+        self.valueList[i] = value
+
+    def addValue(self, value):
+        self.valueList.append(value)
+        return self
+
+    def addBoolean(self, value):
+        self.valueList.append(BooleanValue(value))
+        return self
+
+    def addDouble(self, value):
+        self.valueList.append(DoubleValue(value))
+        return self
+
+    def addLong(self, value):
+        self.valueList.append(DecimalValue(value))
+        return self
+
+    def addFloat(self, value):
+        self.valueList.append(FloatValue(value))
+        return self
+
+    def addString(self, value):
+        self.valueList.append(TextValue(value))
+        return self
+
+    def addStringArray(self, value):
+        if isinstance(value, list):
+            for v in value:
+                self.addString(v)
+        return self
+
+    def addValueArray(self, value):
+        if isinstance(value, list):
+            for v in value:
+                self.addValue(v)
+        return self
+
+    def size(self):
+        return len(self.valueList)
+
+    def write(self, dout):
+        size = self.size()
+        dout.writeDecimal(size)
+        for i in range(size):
+            dout.writeValue(self.valueList[i])
+
+    def read(self, din):
+        for _ in range(din.readDecimal()):
+            self.addValue(din.readValue())
+
+    def getValueType(self):
+        return ValueEnum.LIST
+
+    def toObject(self):
+        return self.valueList

whatap/value/long_array.py

@@ -0,0 +1,44 @@
+from whatap.value.value import Value
+from whatap.value.value_enum import ValueEnum
+
+from whatap.util.compare_util import CompareUtil
+
+
+class LongArray(Value):
+    def __init__(self, value=None):
+        super(LongArray, self).__init__()
+        self.value = value if isinstance(value, list) else []
+        self._hash = 0
+
+    def compareTo(self, object):
+        if isinstance(object, LongArray):
+            return CompareUtil.compareTo(self.value, object.value)
+        return 1
+
+    def equals(self, object):
+        if isinstance(object, LongArray):
+            return self.value == object.value
+        return False
+
+    def hashCode(self):
+        if not self._hash:
+            if not self.value:
+                return 0
+
+            result = 1
+            for v in self.value:
+                element = v ^ (v >> 32)
+                result = 31 * result + element
+
+        self._hash = result
+        return self._hash
+
+    def write(self, dout):
+        dout.writLongeArray(self.value)
+
+    def read(self, din):
+        self.value = din.readLongArray()
+        return self
+
+    def getValueType(self):
+        return ValueEnum.ARRAY_LONG

whatap/value/long_summary.py

@@ -0,0 +1,83 @@
+from whatap.value.summary_value import SummaryValue
+from whatap.value.value_enum import ValueEnum
+
+
+class LongSummary(SummaryValue):
+    def __init__(self):
+        super(LongSummary, self).__init__()
+        self.sum = 0
+        self.count = 0
+        self.min = 0
+        self.max = 0
+
+    def getValueType(self):
+        return ValueEnum.LONG_SUMMARY
+
+    def write(self, dout):
+        dout.writeLong(self.sum)
+        dout.writeInt(self.count)
+        dout.writeLong(self.min)
+        dout.writeLong(self.max)
+
+    def read(self, din):
+        self.sum = din.readLong()
+        self.count = din.readInt()
+        self.min = din.readLong()
+        self.max = din.readLong()
+        return self
+
+    def addCount(self):
+        self.count += 1
+
+    def add(self, value):
+        if not value:
+            return self
+
+        if isinstance(value, int):
+            if not self.count:
+                self.sum = value
+                self.count = 1
+                self.max = value
+                self.min = value
+            else:
+                self.sum += value
+                self.count += 1
+                self.max = max(self.max, value)
+                self.min = min(self.min, value)
+
+        elif isinstance(value, SummaryValue):
+            if not value.getCount():
+                return self
+
+            self.count += value.getCount()
+            self.sum += value.doubleSum()
+            self.min = min(self.min, value.doubleMin())
+            self.max = max(self.max, value.doubleMax())
+        return self
+
+    def longSum(self):
+        return self.sum
+
+    def longMin(self):
+        return self.min
+
+    def longMax(self):
+        return self.max
+
+    def longAvg(self):
+        return 0 if not self.count else self.sum / self.count
+
+    def doubleSum(self):
+        return self.sum
+
+    def doubleMin(self):
+        return self.min
+
+    def doubleMax(self):
+        return self.max
+
+    def doubleAvg(self):
+        return 0 if not self.count else self.sum / self.count
+
+    def getCount(self):
+        return self.count

whatap/value/map_value.py

@@ -0,0 +1,154 @@
+from whatap.value.boolean_value import BooleanValue
+from whatap.value.decimal_value import DecimalValue
+from whatap.value.number_value import NumberValue
+from whatap.value.text_value import TextValue
+from whatap.value.float_value import FloatValue
+from whatap.value.value import Value
+from whatap.value.value_enum import ValueEnum
+
+from whatap.value.list_value import ListValue
+
+
+class MapValue(Value):
+    def __init__(self):
+        super(MapValue, self).__init__()
+        self.table = {} #OrderedDict()
+
+    def equals(self, obj):
+        if self == obj:
+            return True
+        elif not obj:
+            return False
+
+        elif not self.table:
+            if obj.table:
+                return False
+        elif self.table != obj.table:
+            return False
+        return True
+
+    def size(self):
+        return len(self.table)
+
+    def isEmpty(self):
+        return self.size() == 0
+
+    def containsKey(self, key):
+        return self.get(key) is not None
+
+    def keys(self):
+        return self.table.keys()
+
+    def get(self, key):
+        return self.table.get(key)
+
+    def getBoolean(self, key):
+        v = self.get(key)
+        if isinstance(v, BooleanValue):
+            return v.value
+        return False
+
+    def getInt(self, key):
+        v = self.get(key)
+        if isinstance(v, NumberValue):
+            return v.intValue()
+        return 0
+
+    def getLong(self, key):
+        v = self.get(key)
+        if isinstance(v, NumberValue):
+            return v.longValue()
+        return 0
+
+    def getFloat(self, key):
+        v = self.get(key)
+        if isinstance(v, NumberValue):
+            return v.floatValue()
+        return 0
+
+    def getText(self, key):
+        v = self.get(key)
+        if isinstance(v, TextValue):
+            return v.value
+        return None
+
+    def put(self, key, value):
+        self.table[key] = value
+        return self
+
+    def putAuto(self, key, value):
+        # key가 string이 아닐 경우, 경고 메시지를 출력하고 아무 것도 하지 않음
+        if not isinstance(key, str):
+            #print("키는 문자열이어야 합니다.")
+            return self
+
+        # value의 타입에 따라 적절하게 감싸기
+        if isinstance(value, int):
+            wrapped_value = DecimalValue(value)
+        elif isinstance(value, float):
+            wrapped_value = FloatValue(value)
+        elif isinstance(value, (str)):
+            wrapped_value = TextValue(value)
+        else:
+            #print("지원하지 않는 값 타입입니다.")
+            return self
+
+        # key-value 쌍을 저장
+        self.table[key] = wrapped_value
+        return self
+
+    def putValue(self, key, value):
+        self.table[key] = value
+        return self
+
+    def putString(self, key, value):
+        self.table[key] = TextValue(value)
+        return self
+
+    def putLong(self, key, value):
+        self.table[key] = DecimalValue(value)
+
+    def remove(self, key):
+        val = self.table[key]
+        del self.table[key]
+        return val
+
+    def clear(self):
+        self.table = {}
+
+    def getValueType(self):
+        return ValueEnum.MAP
+
+    def write(self, dout):
+        dout.writeDecimal(self.size())
+        for key in self.table.keys():
+            dout.writeText(key)
+            dout.writeValue(self.get(key))
+
+    def read(self, din):
+        count = din.readDecimal()
+        for _ in range(count):
+            key = din.readText()
+            value = din.readValue()
+            self.putValue(key, value)
+        return self
+
+    def newList(self, name):
+        list = ListValue()
+        self.putValue(name, list)
+        return list
+
+    def getList(self, key):
+        return self.get(key)
+
+    def toObject(self):
+        return self.table
+
+    def putAllMap(self, m):
+        for key in self.table.keys():
+            value = m.get(key)
+            if isinstance(value, Value):
+                self.table[key] = value
+
+    def putAllMapValue(self, m):
+        self.putAllMap(m.table)

whatap/value/null_value.py

@@ -0,0 +1,21 @@
+from whatap.value.value import Value
+from whatap.value.value_enum import ValueEnum
+
+
+class NullValue(Value):
+    def __init__(self):
+        super(NullValue, self).__init__()
+
+    def compareTo(self, object):
+        if isinstance(object, NullValue):
+            return 0
+        return 1
+
+    def equals(self, object):
+        return isinstance(object, NullValue)
+
+    def hashCode(self):
+        return 0
+
+    def getValueType(self):
+        return ValueEnum.NULL

whatap/value/number_value.py

@@ -0,0 +1,33 @@
+from whatap.value.value import Value
+from whatap.value.value_enum import ValueEnum
+
+
+class NumberValue(Value):
+    def __init__(self):
+        super(NumberValue, self).__init__()
+
+    def doubleValue(self):
+        return self.value
+
+    def floatValue(self):
+        return self.value
+
+    def intValue(self):
+        return self.value
+
+    def longValue(self):
+        return self.value
+
+    def add(self, num):
+        if not num or not isinstance(num, NumberValue):
+            return self
+
+        if isinstance(num, ValueEnum.DECIMAL):
+            self.value += num.longValue()
+        elif isinstance(num, ValueEnum.FLOAT):
+            self.value += num.floatValue()
+        elif isinstance(num, ValueEnum.DOUBLE):
+            self.value += num.doubleValue()
+        else:
+            from whatap.value.double_value import DoubleValue
+            return DoubleValue(self.doubleValue() + num.doubleValue())

whatap/value/summary_value.py

@@ -0,0 +1,39 @@
+from whatap.value.value import Value
+
+
+class SummaryValue(Value):
+    def __init__(self):
+        super(SummaryValue, self).__init__()
+
+    def add(self, value):
+        return self
+
+    def addCount(self):
+        return
+
+    def longSum(self):
+        return
+
+    def longMin(self):
+        return
+
+    def longMax(self):
+        return
+
+    def longAvg(self):
+        return
+
+    def doubleSum(self):
+        return
+
+    def doubleMin(self):
+        return
+
+    def doubleMax(self):
+        return
+
+    def doubleAvg(self):
+        return
+
+    def getCount(self):
+        return

whatap/value/text_array.py

@@ -0,0 +1,58 @@
+from whatap.value.value import Value
+from whatap.value.value_enum import ValueEnum
+
+from whatap.util.compare_util import CompareUtil
+
+
+class TextArray(Value):
+    def __init__(self, value=None):
+        super(TextArray, self).__init__()
+        self.value = value if isinstance(value, list) else []
+        self._hash = 0
+
+    def compareTo(self, object):
+        if isinstance(object, TextArray):
+            return CompareUtil.compareTo(self.value, object.value)
+        return 1
+
+    def equals(self, object):
+        if isinstance(object, TextArray):
+            return self.value == object.value
+        return False
+
+    def hashCode(self):
+        if not self._hash:
+            if not self.value:
+                return 0
+
+            result = 1
+            for v in self.value:
+                element = v
+                hashtmp = 0
+                if len(element):
+                    for e in element:
+                        hashtmp = ((hashtmp << 5) - hashtmp) + str(e)
+                        hashtmp |= 0
+
+                result = 31 * result + element
+
+        self._hash = result
+        return self._hash
+
+    def write(self, dout):
+        if not self.value:
+            dout.writeShort(0)
+        else:
+            dout.writeShort(self.value)
+            for v in self.value:
+                dout.writeText(v)
+
+    def read(self, din):
+        ln = din.readShort()
+        self.value = [None for _ in range(ln)]
+        for i in range(ln):
+            self.value[i] = din.readText()
+        return self
+
+    def getValueType(self):
+        return ValueEnum.ARRAY_TEXT

whatap/value/text_hash_value.py

@@ -0,0 +1,37 @@
+from whatap.value.value import Value
+from whatap.value.value_enum import ValueEnum
+
+from whatap.util.hash_util import HashUtil
+
+
+class TextHashValue(Value):
+    def __init__(self, value=None):
+        super(TextHashValue, self).__init__()
+        self.value = HashUtil.crc32(value)
+
+    def compareTo(self, object):
+        if isinstance(object, TextHashValue):
+            if self.value < object.value:
+                return -1
+            elif self.value == object.value:
+                return 0
+            return 1
+        return 1
+
+    def equals(self, object):
+        if isinstance(object, TextHashValue):
+            return self.value == object.value
+        return False
+
+    def hashCode(self):
+        return self.value
+
+    def write(self, dout):
+        dout.writeInt(self.value)
+
+    def read(self, din):
+        self.value = din.readInt()
+        return self
+
+    def getValueType(self):
+        return ValueEnum.TEXT_HASH

whatap/value/text_value.py

@@ -0,0 +1,43 @@
+from whatap.value.value import Value
+from whatap.value.value_enum import ValueEnum
+
+from whatap.util.compare_util import CompareUtil
+
+
+class TextValue(Value):
+    def __init__(self, value=None):
+        super(TextValue, self).__init__()
+        self.value = str('' if not value else value)
+    
+    def compareTo(self, object):
+        if isinstance(object, TextValue):
+            return CompareUtil.compareTo(self.value, object.value)
+        return 1
+    
+    def equals(self, object):
+        if isinstance(object, TextValue):
+            if self.value is None:
+                return object.value is None
+            return self.value == object.value
+        return False
+    
+    def hashCode(self):
+        if not self.value:
+            return 0
+            return 0
+        
+        hash = 0
+        if not hash and len(self.value):
+            for v in self.value:
+                hash = 31 * hash + v
+        return hash
+    
+    def write(self, dout):
+        dout.writeText(self.value)
+    
+    def read(self, din):
+        self.value = din.readText()
+        return self
+    
+    def getValueType(self):
+        return ValueEnum.TEXT

whatap/value/value.py

@@ -0,0 +1,26 @@
+class Value(object):
+    def __init__(self):
+        return
+
+    def __repr__(self):
+        to_str = '{0}: '.format(type(self).__name__)
+        for key, value in self.__dict__.items():
+            to_str += '{0}={1}, '.format(key, value)
+        return to_str
+
+    def equals(self, object):
+        if isinstance(object, Value):
+            return self.value == object.value
+        return False
+
+    def getValueType(self):
+        return 0
+
+    def toObject(self):
+        return self
+
+    def write(self, dout):
+        return
+
+    def read(self, din):
+        return self