Snippets

Patrick de Koning WotNumbers 1.10.1.0 partial fix

Created by Patrick de Koning
View revision

File dictpackers.py Added

  • Ignore whitespace
  • Hide word diff 
+# uncompyle6 version 3.7.0
+# Python bytecode 2.7 (62211)
+# Decompiled from: Python 2.7.18 (v2.7.18:8d21aa21f2, Apr 20 2020, 13:19:08) [MSC v.1500 32 bit (Intel)]
+# Embedded file name: scripts/common/DictPackers.py
+import copy
+#from debug_utils import LOG_ERROR
+from binascii import crc32
+from functools import partial
+
+def roundToInt(val):
+    return int(round(val))
+
+
+class DeltaPacker(object):
+
+    def __init__(self, packPredicate=None):
+        self.packPredicate = packPredicate
+
+    def pack(self, seq):
+        if len(seq) == 0:
+            return seq
+        else:
+            ret = [
+             None] * len(seq)
+            s = sorted(seq)
+            if self.packPredicate:
+                p = self.packPredicate
+                s = [ p(v) for v in s ]
+            ret[0] = s[0]
+            for index, v in enumerate(s[1:]):
+                diff = v - s[index]
+                ret[index + 1] = diff
+
+            return ret
+
+    def unpack(self, seq):
+        if len(seq) == 0:
+            return seq
+        else:
+            ret = [
+             None] * len(seq)
+            ret[0] = seq[0]
+            for index in xrange(1, len(seq)):
+                ret[index] = ret[(index - 1)] + seq[index]
+
+            return ret
+
+
+class ValueReplayPacker:
+
+    def pack(self, value):
+        if isinstance(value, str):
+            return value
+        return value.pack()
+
+    def unpack(self, value):
+        return value
+
+
+class DictPacker(object):
+
+    def __init__(self, *metaData):
+        self._metaData = metaData[0]
+        self._checksum = self.checksum(self._metaData)
+
+    def pack(self, dataDict):
+        metaData = self._metaData
+        l = [None] * (len(metaData) + 1)
+        l[0] = self._checksum
+        for index, metaEntry in enumerate(metaData):
+            try:
+                name, transportType, default, packer, aggFunc = metaEntry
+                v = dataDict.get(name, default)
+                if v is None:
+                    pass
+                elif v == default:
+                    v = None
+                elif packer is not None:
+                    v = packer.pack(v)
+                elif transportType is not None and not isinstance(v, transportType):
+                    v = transportType(v)
+                    if v == default:
+                        v = None
+                l[index + 1] = v
+            except Exception as e:
+                #LOG_ERROR('error while packing:', index, metaEntry, str(e))
+                raise
+
+        return l
+
+    def unpack(self, dataList):
+        ret = {}
+        if len(dataList) == 0 or dataList[0] != self._checksum:
+            return
+        for index, meta in enumerate(self._metaData):
+            val = dataList[(index + 1)]
+            name = meta[0]
+            packer = meta[3]
+            if val is None:
+                val = self.getDefaultValue(index)
+            elif packer is not None:
+                val = packer.unpack(val)
+            ret[name] = val
+
+        return ret
+
+    def unpackWthoutChecksum(self, dataList):
+        ret = {}
+        for index, meta in enumerate(self._metaData):
+            val = dataList[(index + 1)]
+            name = meta[0]
+            packer = meta[3]
+            if val is None:
+                val = self.getDefaultValue(index)
+            elif packer is not None:
+                val = packer.unpack(val)
+            ret[name] = val
+
+        return ret
+
+    # def getChecksum(self):
+    #     return self._checksum
+
+    def getDefaultValue(self, index):
+        default = self._metaData[index][2]
+        return copy.deepcopy(default)
+
+    @staticmethod
+    def checksum(metaData):
+        meta_descriptor = []
+        for entry in metaData:
+            name, entry_type, default, packer, aggregatorName, battle_result_entry_type = entry
+            meta_descriptor.append(('').join([name, str(entry_type),
+              str(default), str(type(packer)), str(aggregatorName), str(battle_result_entry_type)]))
+
+        return crc32(('').join(meta_descriptor))
+
+
+class SimpleDictPacker(object):
+
+    def __init__(self, packPredicate, keys):
+        self.__packPredicate = packPredicate
+        self.__keys = tuple(keys)
+
+    def pack(self, dataDict):
+        packPredicate = self.__packPredicate
+        ret = [None] * len(self.__keys)
+        for index, key in enumerate(self.__keys):
+            val = dataDict.get(key, None)
+            if val is not None:
+                val = packPredicate(val)
+            ret[index] = val
+
+        return ret
+
+    def unpack(self, dataList):
+        ret = {}
+        for index, value in enumerate(dataList):
+            if value is not None:
+                ret[self.__keys[index]] = value
+
+        return ret
+
+#added
+class MetaEntry(object):
+    __slots__ = ('name', 'transportType', 'default', 'packer', 'aggFunc')
+
+    def __init__(self, *data):
+        self.name, self.transportType, default, self.packer, self.aggFunc = data
+        self.default = copy.deepcopy(default)
+
+class Meta(DictPacker):
+
+    def __init__(self, *metaData):
+        DictPacker.__init__(self, *metaData)
+        self.__nameToData = {name:(index, transportType, default, packer, aggFunc) for index, (name, transportType, default, packer, aggFunc, battle_result_entry_type) in enumerate(self._metaData)}
+        self.__names = set(self.__nameToData.keys())
+        #self.__initDefaults()
+
+    def names(self):
+        return self.__names
+
+    # def defaults(self):
+    #     result = self.__defaultsImmutable.copy()
+    #     for key, value in self.__defaultsMutable.iteritems():
+    #         result[key] = value()
+
+    #     return result
+
+    # def indexOf(self, name):
+    #     return self.__nameToData[name][0]
+
+    # def nameOf(self, index):
+    #     return self._metaData[index][0]
+
+    # def getDataByName(self, name):
+    #     return self.__nameToData[name]
+
+    # def getDefaultValue(self, index):
+    #     name, _, _, _, _ = self._metaData[index]
+    #     return self.getDefaultValueByName(name)
+
+    # def getDefaultValueByName(self, name):
+    #     if name in self.__defaultsImmutable:
+    #         return self.__defaultsImmutable[name]
+    #     return self.__defaultsMutable[name]()
+
+    def __add__(self, other):
+        newMeta = self._metaData + other._metaData
+        return Meta(*newMeta)
+
+    def __iter__(self):
+        return self._metaData.__iter__()
+
+    def __len__(self):
+        return len(self._metaData)
+
+    #added
+    def __getitem__(self, index):
+        return MetaEntry(*self._metaData[index])
+
+    # def __initDefaults(self):
+    #     self.__defaultsImmutable = {}
+    #     self.__defaultsMutable = {}
+    #     for name, transportType, default, _, _ in self._metaData:
+    #         mutableType = getMutability(transportType, default)
+    #         if mutableType == 'immutable':
+    #             self.__defaultsImmutable[name] = default
+    #         else:
+    #             lambdas = {'mutableList': partial(lambda x: x[:], default), 
+    #                'mutableDeep': partial(copy.deepcopy, default), 
+    #                'mutableCopy': partial(lambda x: x.copy(), default)}
+    #             self.__defaultsMutable[name] = lambdas[mutableType]
+
+
+# def getMutability(transportType, default):
+    # if transportType in (int, float, str, bool, None):
+    #     return 'immutable'
+    # else:
+    #     if transportType in (list, tuple, set):
+    #         if all(getMutability(type(value), value) == 'immutable' for value in default):
+    #             if transportType == list:
+    #                 return 'mutableList'
+    #             if transportType == tuple:
+    #                 return 'immutable'
+    #             return 'mutableCopy'
+    #     if default or transportType != dict:
+    #         return 'mutableDeep'
+    #     return 'mutableCopy'
HTTPS SSH

You can clone a snippet to your computer for local editing. Learn more.