dynamicserialize.ThriftSerializationContext.ThriftSerializationContext.readMessageEnd() - Code Metrics - Unidata/python-awips - Measure and Improve Code Quality continuously with Scrutinizer

ThriftSerializationContext.readMessageEnd() A
last analyzed 2020-10-19 17:29 UTC

↳ Parent: dynamicserialize.ThriftSerializationContext

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	2
Ratio	100 %

Importance

Changes

Metric	Value
eloc	2
dl	2
loc	2
rs	10
c	0
b	0
f	0
cc	1
nop	1

#
# A port of the Java ThriftSerializationContext, used for reading/writing
# DynamicSerialize objects to/from thrift.
#
# For serialization, it has no knowledge of the expected types in other
# languages, it is instead all based on inspecting the types of the objects
# passed to it.  Therefore, ensure the types of python objects and primitives
# match what they should be in the destination language.
#
#
#    SOFTWARE HISTORY
#
#    Date            Ticket#       Engineer       Description
#    ------------    ----------    -----------    --------------------------
#    06/09/10                      njensen       Initial Creation.
#    06/12/13         #2099        dgilling      Implement readObject() and
#                                                writeObject().
#    Apr 24, 2015    4425          nabowle       Add Double support
#    Oct 17, 2016    5919          njensen       Optimized for speed
#    Sep 06, 2018                  mjames@ucar   Python3 compliance
#
#

import inspect
import sys
import types
import six
import numpy
from thrift.Thrift import TType
import dynamicserialize
from dynamicserialize import dstypes, adapters
from dynamicserialize import SelfDescribingBinaryProtocol

DS_LEN = len('dynamicserialize.dstypes.')

dsObjTypes = {}


def buildObjMap(module):

    if '__all__' in module.__dict__:
        for i in module.__all__:
            name = module.__name__ + '.' + i
            __import__(name)
            buildObjMap(sys.modules[name])
    else:
        clzName = module.__name__[module.__name__.rfind('.') + 1:]
        clz = module.__dict__[clzName]
        tname = module.__name__
        tname = tname[DS_LEN:]
        dsObjTypes[tname] = clz


buildObjMap(dstypes)

if six.PY2:

    pythonToThriftMap = {
        types.StringType: TType.STRING,
        types.IntType: TType.I32,
        types.LongType: TType.I64,
        types.ListType: TType.LIST,
        unicode: TType.STRING,

        types.DictionaryType: TType.MAP,
        type(set([])): TType.SET,
        types.FloatType: SelfDescribingBinaryProtocol.FLOAT,
        # types.FloatType: TType.DOUBLE,
        types.BooleanType: TType.BOOL,
        types.InstanceType: TType.STRUCT,
        types.NoneType: TType.VOID,
        numpy.float32: SelfDescribingBinaryProtocol.FLOAT,
        numpy.int32: TType.I32,
        numpy.ndarray: TType.LIST,
        numpy.object_: TType.STRING,  # making an assumption here
        numpy.string_: TType.STRING,
        numpy.float64: TType.DOUBLE,
        numpy.int16: TType.I16,
        numpy.int8: TType.BYTE,
        numpy.int64: TType.I64
    }
else:
    pythonToThriftMap = {
        bytes: TType.STRING,
        int: TType.I32,
        int: TType.I64,
        list: TType.LIST,
        dict: TType.MAP,
        type(set([])): TType.SET,
        float: SelfDescribingBinaryProtocol.FLOAT,
        # types.FloatType: TType.DOUBLE,
        bool: TType.BOOL,
        object: TType.STRUCT,
        str: TType.STRING,
        type(None): TType.VOID,
        numpy.float32: SelfDescribingBinaryProtocol.FLOAT,
        numpy.int32: TType.I32,
        numpy.ndarray: TType.LIST,
        numpy.object_: TType.STRING,  # making an assumption here
        numpy.string_: TType.STRING,
        numpy.float64: TType.DOUBLE,
        numpy.int16: TType.I16,
        numpy.int8: TType.BYTE,
        numpy.int64: TType.I64
    }

primitiveSupport = (TType.BYTE, TType.I16, TType.I32, TType.I64,
                    SelfDescribingBinaryProtocol.FLOAT, TType.DOUBLE)


class ThriftSerializationContext(object):


    def __init__(self, serializationManager, selfDescribingBinaryProtocol):
        self.serializationManager = serializationManager
        self.protocol = selfDescribingBinaryProtocol
        self.typeDeserializationMethod = {
            TType.STRING: self.protocol.readString,
            TType.I16: self.protocol.readI16,
            TType.I32: self.protocol.readI32,
            TType.LIST: self._deserializeArray,
            TType.MAP: self._deserializeMap,
            TType.SET: self._deserializeSet,
            SelfDescribingBinaryProtocol.FLOAT: self.protocol.readFloat,
            TType.BYTE: self.protocol.readByte,
            TType.I64: self.protocol.readI64,
            TType.DOUBLE: self.protocol.readDouble,
            TType.BOOL: self.protocol.readBool,
            TType.STRUCT: self.deserializeMessage,
            TType.VOID: lambda: None
        }
        self.typeSerializationMethod = {
            TType.STRING: self.protocol.writeString,
            TType.I16: self.protocol.writeI16,
            TType.I32: self.protocol.writeI32,
            TType.LIST: self._serializeArray,
            TType.MAP: self._serializeMap,
            TType.SET: self._serializeSet,
            SelfDescribingBinaryProtocol.FLOAT: self.protocol.writeFloat,
            TType.BYTE: self.protocol.writeByte,
            TType.I64: self.protocol.writeI64,
            TType.DOUBLE: self.protocol.writeDouble,
            TType.BOOL: self.protocol.writeBool,
            TType.STRUCT: self.serializeMessage,
            TType.VOID: lambda x: None
        }
        self.listDeserializationMethod = {
            TType.BYTE: self.protocol.readI8List,
            TType.I16: self.protocol.readI16List,
            TType.I32: self.protocol.readI32List,
            TType.I64: self.protocol.readI64List,
            SelfDescribingBinaryProtocol.FLOAT: self.protocol.readF32List,
            TType.DOUBLE: self.protocol.readF64List
        }
        self.listSerializationMethod = {
            TType.BYTE: self.protocol.writeI8List,
            TType.I16: self.protocol.writeI16List,
            TType.I32: self.protocol.writeI32List,
            TType.I64: self.protocol.writeI64List,
            SelfDescribingBinaryProtocol.FLOAT: self.protocol.writeF32List,
            TType.DOUBLE: self.protocol.writeF64List
        }

    def readMessageStart(self):
        msg = self.protocol.readMessageBegin()
        return msg[0]

    def readMessageEnd(self):
        self.protocol.readMessageEnd()

    def deserializeMessage(self):
        name = self.protocol.readStructBegin()
        name = name.decode('cp437')
        name = name.replace('_', '.')
        if name.isdigit():
            obj = self._deserializeType(int(name))
            return obj
        if name in adapters.classAdapterRegistry:
            return adapters.classAdapterRegistry[name].deserialize(self)
        elif '$' in name:
            # it's an inner class, we're going to hope it's an enum, treat it
            # special
            fieldName, fieldType, fieldId = self.protocol.readFieldBegin()
            if fieldName.decode('utf8') != '__enumValue__':
                raise dynamicserialize.SerializationException(
                    "Expected to find enum payload.  Found: " + fieldName)
            obj = self.protocol.readString()
            self.protocol.readFieldEnd()
            return obj
        else:
            clz = dsObjTypes[name]
            obj = clz()

        while self._deserializeField(obj):
            pass

        self.protocol.readStructEnd()
        return obj

    def _deserializeType(self, b):
        try:
            return self.typeDeserializationMethod[b]()
        except KeyError:
            raise dynamicserialize.SerializationException(
                "Unsupported type value " + str(b))

    def _deserializeField(self, obj):
        fieldName, fieldType, fieldId = self.protocol.readFieldBegin()
        if fieldType == TType.STOP:
            return False
        elif fieldType != TType.VOID:
            result = self._deserializeType(fieldType)
            fn_str = bytes.decode(fieldName)
            lookingFor = "set" + fn_str[0].upper() + fn_str[1:]

            try:
                setMethod = getattr(obj, lookingFor)
                setMethod(result)
            except ValueError:
                raise dynamicserialize.SerializationException(
                    "Couldn't find setter method " + lookingFor)

        self.protocol.readFieldEnd()
        return True

    def _deserializeArray(self):
        listType, size = self.protocol.readListBegin()
        result = []
        if size:
            if listType not in primitiveSupport:
                m = self.typeDeserializationMethod[listType]
                result = [m() for __ in range(size)]
            else:
                result = self.listDeserializationMethod[listType](size)
        self.protocol.readListEnd()
        return result

    def _deserializeMap(self):
        keyType, valueType, size = self.protocol.readMapBegin()
        result = {}
        for __ in range(size):
            # can't go off the type, due to java generics limitations dynamic serialize is
            # serializing keys and values as void
            key = self.typeDeserializationMethod[TType.STRUCT]()
            value = self.typeDeserializationMethod[TType.STRUCT]()
            result[key] = value
        self.protocol.readMapEnd()
        return result

    def _deserializeSet(self):
        setType, setSize = self.protocol.readSetBegin()
        result = set([])
        for __ in range(setSize):
            result.add(self.typeDeserializationMethod[TType.STRUCT]())
        self.protocol.readSetEnd()
        return result

    def _lookupType(self, obj):
        pyt = type(obj)
        if pyt in pythonToThriftMap:
            return pythonToThriftMap[pyt]
        elif pyt.__module__[:DS_LEN - 1] == ('dynamicserialize.dstypes'):
            if six.PY2:
                return pythonToThriftMap[types.InstanceType]
            return pythonToThriftMap[object]
        raise dynamicserialize.SerializationException(
            "Don't know how to serialize object of type: " + str(pyt))

    def serializeMessage(self, obj):
        tt = self._lookupType(obj)

        if tt == TType.STRUCT:
            fqn = obj.__module__[DS_LEN:]
            if fqn in adapters.classAdapterRegistry:
                # get proper class name when writing class name to serialization stream
                # in case we have a special inner-class case
                m = sys.modules[adapters.classAdapterRegistry[fqn].__name__]
                if isinstance(m.ClassAdapter, list):
                    fqn = m.ClassAdapter[0]
                self.protocol.writeStructBegin(fqn)
                adapters.classAdapterRegistry[fqn].serialize(self, obj)
                return
            else:
                self.protocol.writeStructBegin(fqn)
                methods = inspect.getmembers(obj, inspect.ismethod)
                fid = 1
                for m in methods:
                    methodName = m[0]
                    if methodName.startswith('get'):
                        fieldname = methodName[3].lower() + methodName[4:]
                        val = m[1]()
                        ft = self._lookupType(val)
                        if ft == TType.STRUCT:
                            self._serializeField(fieldname, ft, fid, val)
                        else:
                            self._serializeField(fieldname, ft, fid, val)
                        fid += 1
                self.protocol.writeFieldStop()

                self.protocol.writeStructEnd()
        else:
            # basic types
            self.protocol.writeStructBegin(str(tt))
            self._serializeType(obj, tt)
            self.protocol.writeStructEnd()

    def _serializeField(self, fieldName, fieldType, fieldId, fieldValue):
        self.protocol.writeFieldBegin(fieldName, fieldType, fieldId)
        self._serializeType(fieldValue, fieldType)
        self.protocol.writeFieldEnd()

    def _serializeType(self, fieldValue, fieldType):
        if fieldType in self.typeSerializationMethod:
            return self.typeSerializationMethod[fieldType](fieldValue)
        else:
            raise dynamicserialize.SerializationException(
                "Unsupported type value " + str(fieldType))

    def _serializeArray(self, obj):
        size = len(obj)
        if size:
            if isinstance(obj, numpy.ndarray):
                t = pythonToThriftMap[obj.dtype.type]
                size = obj.size
            else:
                t = self._lookupType(obj[0])
        else:
            t = TType.STRUCT
        self.protocol.writeListBegin(t, size)
        if t == TType.STRING:
            if isinstance(obj, numpy.ndarray):
                if len(obj.shape) == 1:
                    for x in obj:
                        s = str(x).strip()
                        self.typeSerializationMethod[t](s)
                else:
                    for x in obj:
                        for y in x:
                            s = str(y).strip()
                            self.typeSerializationMethod[t](s)
            else:
                for x in obj:
                    s = str(x)
                    self.typeSerializationMethod[t](s)
        elif t not in primitiveSupport:
            for x in obj:
                self.typeSerializationMethod[t](x)
        else:
            self.listSerializationMethod[t](obj)
        self.protocol.writeListEnd()

    def _serializeMap(self, obj):
        size = len(obj)
        self.protocol.writeMapBegin(TType.VOID, TType.VOID, size)
        for k in list(obj.keys()):
            self.typeSerializationMethod[TType.STRUCT](k)
            self.typeSerializationMethod[TType.STRUCT](obj[k])
        self.protocol.writeMapEnd()

    def _serializeSet(self, obj):
        size = len(obj)
        self.protocol.writeSetBegin(TType.VOID, size)
        for x in obj:
            self.typeSerializationMethod[TType.STRUCT](x)
        self.protocol.writeSetEnd()

    def writeMessageStart(self, name):
        self.protocol.writeMessageBegin(name, TType.VOID, 0)

    def writeMessageEnd(self):
        self.protocol.writeMessageEnd()

    def readBool(self):
        return self.protocol.readBool()

    def writeBool(self, b):
        self.protocol.writeBool(b)

    def readByte(self):
        return self.protocol.readByte()

    def writeByte(self, b):
        self.protocol.writeByte(b)

    def readDouble(self):
        return self.protocol.readDouble()

    def writeDouble(self, d):
        self.protocol.writeDouble(d)

    def readFloat(self):
        return self.protocol.readFloat()

    def writeFloat(self, f):
        self.protocol.writeFloat(f)

    def readI16(self):
        return self.protocol.readI16()

    def writeI16(self, i):
        self.protocol.writeI16(i)

    def readI32(self):
        return self.protocol.readI32()

    def writeI32(self, i):
        self.protocol.writeI32(i)

    def readI64(self):
        return self.protocol.readI64()

    def writeI64(self, i):
        self.protocol.writeI64(i)

    def readString(self):
        return self.protocol.readString()

    def writeString(self, s):
        self.protocol.writeString(s)

    def readBinary(self):
        numBytes = self.protocol.readI32()
        return self.protocol.readI8List(numBytes)

    def readFloatArray(self):
        size = self.protocol.readI32()
        return self.protocol.readF32List(size)

    def writeFloatArray(self, floats):
        self.protocol.writeI32(len(floats))
        self.protocol.writeF32List(floats)

    def readObject(self):
        return self.deserializeMessage()

    def writeObject(self, obj):
        self.serializeMessage(obj)


1		#
2		# A port of the Java ThriftSerializationContext, used for reading/writing
3		# DynamicSerialize objects to/from thrift.
4		#
5		# For serialization, it has no knowledge of the expected types in other
6		# languages, it is instead all based on inspecting the types of the objects
7		# passed to it. Therefore, ensure the types of python objects and primitives
8		# match what they should be in the destination language.
9		#
10		#
11		# SOFTWARE HISTORY
12		#
13		# Date Ticket# Engineer Description
14		# ------------ ---------- ----------- --------------------------
15		# 06/09/10 njensen Initial Creation.
16		# 06/12/13 #2099 dgilling Implement readObject() and
17		# writeObject().
18		# Apr 24, 2015 4425 nabowle Add Double support
19		# Oct 17, 2016 5919 njensen Optimized for speed
20		# Sep 06, 2018 mjames@ucar Python3 compliance
21		#
22		#
23
24		import inspect
25		import sys
26		import types
27		import six
28		import numpy
29		from thrift.Thrift import TType
30		import dynamicserialize
31		from dynamicserialize import dstypes, adapters
32		from dynamicserialize import SelfDescribingBinaryProtocol
33
34		DS_LEN = len('dynamicserialize.dstypes.')
35
36		dsObjTypes = {}
37
38
39	View Code Duplication	def buildObjMap(module):
		0 ignored issues – show Duplication introduced 2018-10-02 00:51 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
40		if '__all__' in module.__dict__:
41		for i in module.__all__:
42		name = module.__name__ + '.' + i
43		__import__(name)
44		buildObjMap(sys.modules[name])
45		else:
46		clzName = module.__name__[module.__name__.rfind('.') + 1:]
47		clz = module.__dict__[clzName]
48		tname = module.__name__
49		tname = tname[DS_LEN:]
50		dsObjTypes[tname] = clz
51
52
53		buildObjMap(dstypes)
54
55	View Code Duplication	if six.PY2:
		0 ignored issues – show Duplication introduced 2018-10-09 21:15 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
56		pythonToThriftMap = {
57		types.StringType: TType.STRING,
58		types.IntType: TType.I32,
59		types.LongType: TType.I64,
60		types.ListType: TType.LIST,
61		unicode: TType.STRING,
		0 ignored issues – show Comprehensibility Best Practice introduced 2018-10-09 21:15 UTC by Report Bug Copy Issue Report The variable `unicode` does not seem to be defined. Loading history...
62		types.DictionaryType: TType.MAP,
63		type(set([])): TType.SET,
64		types.FloatType: SelfDescribingBinaryProtocol.FLOAT,
65		# types.FloatType: TType.DOUBLE,
66		types.BooleanType: TType.BOOL,
67		types.InstanceType: TType.STRUCT,
68		types.NoneType: TType.VOID,
69		numpy.float32: SelfDescribingBinaryProtocol.FLOAT,
70		numpy.int32: TType.I32,
71		numpy.ndarray: TType.LIST,
72		numpy.object_: TType.STRING, # making an assumption here
73		numpy.string_: TType.STRING,
74		numpy.float64: TType.DOUBLE,
75		numpy.int16: TType.I16,
76		numpy.int8: TType.BYTE,
77		numpy.int64: TType.I64
78		}
79		else:
80		pythonToThriftMap = {
81		bytes: TType.STRING,
82		int: TType.I32,
83		int: TType.I64,
84		list: TType.LIST,
85		dict: TType.MAP,
86		type(set([])): TType.SET,
87		float: SelfDescribingBinaryProtocol.FLOAT,
88		# types.FloatType: TType.DOUBLE,
89		bool: TType.BOOL,
90		object: TType.STRUCT,
91		str: TType.STRING,
92		type(None): TType.VOID,
93		numpy.float32: SelfDescribingBinaryProtocol.FLOAT,
94		numpy.int32: TType.I32,
95		numpy.ndarray: TType.LIST,
96		numpy.object_: TType.STRING, # making an assumption here
97		numpy.string_: TType.STRING,
98		numpy.float64: TType.DOUBLE,
99		numpy.int16: TType.I16,
100		numpy.int8: TType.BYTE,
101		numpy.int64: TType.I64
102		}
103
104		primitiveSupport = (TType.BYTE, TType.I16, TType.I32, TType.I64,
105		SelfDescribingBinaryProtocol.FLOAT, TType.DOUBLE)
106
107
108	View Code Duplication	class ThriftSerializationContext(object):
		0 ignored issues – show Duplication introduced 2018-10-02 00:51 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
109
110		def __init__(self, serializationManager, selfDescribingBinaryProtocol):
111		self.serializationManager = serializationManager
112		self.protocol = selfDescribingBinaryProtocol
113		self.typeDeserializationMethod = {
114		TType.STRING: self.protocol.readString,
115		TType.I16: self.protocol.readI16,
116		TType.I32: self.protocol.readI32,
117		TType.LIST: self._deserializeArray,
118		TType.MAP: self._deserializeMap,
119		TType.SET: self._deserializeSet,
120		SelfDescribingBinaryProtocol.FLOAT: self.protocol.readFloat,
121		TType.BYTE: self.protocol.readByte,
122		TType.I64: self.protocol.readI64,
123		TType.DOUBLE: self.protocol.readDouble,
124		TType.BOOL: self.protocol.readBool,
125		TType.STRUCT: self.deserializeMessage,
126		TType.VOID: lambda: None
127		}
128		self.typeSerializationMethod = {
129		TType.STRING: self.protocol.writeString,
130		TType.I16: self.protocol.writeI16,
131		TType.I32: self.protocol.writeI32,
132		TType.LIST: self._serializeArray,
133		TType.MAP: self._serializeMap,
134		TType.SET: self._serializeSet,
135		SelfDescribingBinaryProtocol.FLOAT: self.protocol.writeFloat,
136		TType.BYTE: self.protocol.writeByte,
137		TType.I64: self.protocol.writeI64,
138		TType.DOUBLE: self.protocol.writeDouble,
139		TType.BOOL: self.protocol.writeBool,
140		TType.STRUCT: self.serializeMessage,
141		TType.VOID: lambda x: None
142		}
143		self.listDeserializationMethod = {
144		TType.BYTE: self.protocol.readI8List,
145		TType.I16: self.protocol.readI16List,
146		TType.I32: self.protocol.readI32List,
147		TType.I64: self.protocol.readI64List,
148		SelfDescribingBinaryProtocol.FLOAT: self.protocol.readF32List,
149		TType.DOUBLE: self.protocol.readF64List
150		}
151		self.listSerializationMethod = {
152		TType.BYTE: self.protocol.writeI8List,
153		TType.I16: self.protocol.writeI16List,
154		TType.I32: self.protocol.writeI32List,
155		TType.I64: self.protocol.writeI64List,
156		SelfDescribingBinaryProtocol.FLOAT: self.protocol.writeF32List,
157		TType.DOUBLE: self.protocol.writeF64List
158		}
159
160		def readMessageStart(self):
161		msg = self.protocol.readMessageBegin()
162		return msg[0]
163
164		def readMessageEnd(self):
165		self.protocol.readMessageEnd()
166
167		def deserializeMessage(self):
168		name = self.protocol.readStructBegin()
169		name = name.decode('cp437')
170		name = name.replace('_', '.')
171		if name.isdigit():
172		obj = self._deserializeType(int(name))
173		return obj
174		if name in adapters.classAdapterRegistry:
175		return adapters.classAdapterRegistry[name].deserialize(self)
176		elif '$' in name:
177		# it's an inner class, we're going to hope it's an enum, treat it
178		# special
179		fieldName, fieldType, fieldId = self.protocol.readFieldBegin()
180		if fieldName.decode('utf8') != '__enumValue__':
181		raise dynamicserialize.SerializationException(
182		"Expected to find enum payload. Found: " + fieldName)
183		obj = self.protocol.readString()
184		self.protocol.readFieldEnd()
185		return obj
186		else:
187		clz = dsObjTypes[name]
188		obj = clz()
189
190		while self._deserializeField(obj):
191		pass
192
193		self.protocol.readStructEnd()
194		return obj
195
196		def _deserializeType(self, b):
197		try:
198		return self.typeDeserializationMethod[b]()
199		except KeyError:
200		raise dynamicserialize.SerializationException(
201		"Unsupported type value " + str(b))
202
203		def _deserializeField(self, obj):
204		fieldName, fieldType, fieldId = self.protocol.readFieldBegin()
205		if fieldType == TType.STOP:
206		return False
207		elif fieldType != TType.VOID:
208		result = self._deserializeType(fieldType)
209		fn_str = bytes.decode(fieldName)
210		lookingFor = "set" + fn_str[0].upper() + fn_str[1:]
211
212		try:
213		setMethod = getattr(obj, lookingFor)
214		setMethod(result)
215		except ValueError:
216		raise dynamicserialize.SerializationException(
217		"Couldn't find setter method " + lookingFor)
218
219		self.protocol.readFieldEnd()
220		return True
221
222		def _deserializeArray(self):
223		listType, size = self.protocol.readListBegin()
224		result = []
225		if size:
226		if listType not in primitiveSupport:
227		m = self.typeDeserializationMethod[listType]
228		result = [m() for __ in range(size)]
229		else:
230		result = self.listDeserializationMethod[listType](size)
231		self.protocol.readListEnd()
232		return result
233
234		def _deserializeMap(self):
235		keyType, valueType, size = self.protocol.readMapBegin()
236		result = {}
237		for __ in range(size):
238		# can't go off the type, due to java generics limitations dynamic serialize is
239		# serializing keys and values as void
240		key = self.typeDeserializationMethod[TType.STRUCT]()
241		value = self.typeDeserializationMethod[TType.STRUCT]()
242		result[key] = value
243		self.protocol.readMapEnd()
244		return result
245
246		def _deserializeSet(self):
247		setType, setSize = self.protocol.readSetBegin()
248		result = set([])
249		for __ in range(setSize):
250		result.add(self.typeDeserializationMethod[TType.STRUCT]())
251		self.protocol.readSetEnd()
252		return result
253
254		def _lookupType(self, obj):
255		pyt = type(obj)
256		if pyt in pythonToThriftMap:
257		return pythonToThriftMap[pyt]
258		elif pyt.__module__[:DS_LEN - 1] == ('dynamicserialize.dstypes'):
259		if six.PY2:
260		return pythonToThriftMap[types.InstanceType]
261		return pythonToThriftMap[object]
262		raise dynamicserialize.SerializationException(
263		"Don't know how to serialize object of type: " + str(pyt))
264
265		def serializeMessage(self, obj):
266		tt = self._lookupType(obj)
267
268		if tt == TType.STRUCT:
269		fqn = obj.__module__[DS_LEN:]
270		if fqn in adapters.classAdapterRegistry:
271		# get proper class name when writing class name to serialization stream
272		# in case we have a special inner-class case
273		m = sys.modules[adapters.classAdapterRegistry[fqn].__name__]
274		if isinstance(m.ClassAdapter, list):
275		fqn = m.ClassAdapter[0]
276		self.protocol.writeStructBegin(fqn)
277		adapters.classAdapterRegistry[fqn].serialize(self, obj)
278		return
279		else:
280		self.protocol.writeStructBegin(fqn)
281		methods = inspect.getmembers(obj, inspect.ismethod)
282		fid = 1
283		for m in methods:
284		methodName = m[0]
285		if methodName.startswith('get'):
286		fieldname = methodName[3].lower() + methodName[4:]
287		val = m[1]()
288		ft = self._lookupType(val)
289		if ft == TType.STRUCT:
290		self._serializeField(fieldname, ft, fid, val)
291		else:
292		self._serializeField(fieldname, ft, fid, val)
293		fid += 1
294		self.protocol.writeFieldStop()
295
296		self.protocol.writeStructEnd()
297		else:
298		# basic types
299		self.protocol.writeStructBegin(str(tt))
300		self._serializeType(obj, tt)
301		self.protocol.writeStructEnd()
302
303		def _serializeField(self, fieldName, fieldType, fieldId, fieldValue):
304		self.protocol.writeFieldBegin(fieldName, fieldType, fieldId)
305		self._serializeType(fieldValue, fieldType)
306		self.protocol.writeFieldEnd()
307
308		def _serializeType(self, fieldValue, fieldType):
309		if fieldType in self.typeSerializationMethod:
310		return self.typeSerializationMethod[fieldType](fieldValue)
311		else:
312		raise dynamicserialize.SerializationException(
313		"Unsupported type value " + str(fieldType))
314
315		def _serializeArray(self, obj):
316		size = len(obj)
317		if size:
318		if isinstance(obj, numpy.ndarray):
319		t = pythonToThriftMap[obj.dtype.type]
320		size = obj.size
321		else:
322		t = self._lookupType(obj[0])
323		else:
324		t = TType.STRUCT
325		self.protocol.writeListBegin(t, size)
326		if t == TType.STRING:
327		if isinstance(obj, numpy.ndarray):
328		if len(obj.shape) == 1:
329		for x in obj:
330		s = str(x).strip()
331		self.typeSerializationMethod[t](s)
332		else:
333		for x in obj:
334		for y in x:
335		s = str(y).strip()
336		self.typeSerializationMethod[t](s)
337		else:
338		for x in obj:
339		s = str(x)
340		self.typeSerializationMethod[t](s)
341		elif t not in primitiveSupport:
342		for x in obj:
343		self.typeSerializationMethod[t](x)
344		else:
345		self.listSerializationMethod[t](obj)
346		self.protocol.writeListEnd()
347
348		def _serializeMap(self, obj):
349		size = len(obj)
350		self.protocol.writeMapBegin(TType.VOID, TType.VOID, size)
351		for k in list(obj.keys()):
352		self.typeSerializationMethod[TType.STRUCT](k)
353		self.typeSerializationMethod[TType.STRUCT](obj[k])
354		self.protocol.writeMapEnd()
355
356		def _serializeSet(self, obj):
357		size = len(obj)
358		self.protocol.writeSetBegin(TType.VOID, size)
359		for x in obj:
360		self.typeSerializationMethod[TType.STRUCT](x)
361		self.protocol.writeSetEnd()
362
363		def writeMessageStart(self, name):
364		self.protocol.writeMessageBegin(name, TType.VOID, 0)
365
366		def writeMessageEnd(self):
367		self.protocol.writeMessageEnd()
368
369		def readBool(self):
370		return self.protocol.readBool()
371
372		def writeBool(self, b):
373		self.protocol.writeBool(b)
374
375		def readByte(self):
376		return self.protocol.readByte()
377
378		def writeByte(self, b):
379		self.protocol.writeByte(b)
380
381		def readDouble(self):
382		return self.protocol.readDouble()
383
384		def writeDouble(self, d):
385		self.protocol.writeDouble(d)
386
387		def readFloat(self):
388		return self.protocol.readFloat()
389
390		def writeFloat(self, f):
391		self.protocol.writeFloat(f)
392
393		def readI16(self):
394		return self.protocol.readI16()
395
396		def writeI16(self, i):
397		self.protocol.writeI16(i)
398
399		def readI32(self):
400		return self.protocol.readI32()
401
402		def writeI32(self, i):
403		self.protocol.writeI32(i)
404
405		def readI64(self):
406		return self.protocol.readI64()
407
408		def writeI64(self, i):
409		self.protocol.writeI64(i)
410
411		def readString(self):
412		return self.protocol.readString()
413
414		def writeString(self, s):
415		self.protocol.writeString(s)
416
417		def readBinary(self):
418		numBytes = self.protocol.readI32()
419		return self.protocol.readI8List(numBytes)
420
421		def readFloatArray(self):
422		size = self.protocol.readI32()
423		return self.protocol.readF32List(size)
424
425		def writeFloatArray(self, floats):
426		self.protocol.writeI32(len(floats))
427		self.protocol.writeF32List(floats)
428
429		def readObject(self):
430		return self.deserializeMessage()
431
432		def writeObject(self, obj):
433		self.serializeMessage(obj)
434

Unidata / python-awips

ThriftSerializationContext.readMessageEnd() A last analyzed 2020-10-19 17:29 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ThriftSerializationContext.readMessageEnd() A
last analyzed 2020-10-19 17:29 UTC