Models: object detection API，test the train result,report google.protobuf.message.DecodeError: Truncated message.

Created on 8 Aug 2018 · 2Comments · Source: tensorflow/models

Please go to Stack Overflow for help and support:

http://stackoverflow.com/questions/tagged/tensorflow

Also, please understand that many of the models included in this repository are experimental and research-style code. If you open a GitHub issue, here is our policy:

It must be a bug, a feature request, or a significant problem with documentation (for small docs fixes please send a PR instead).
The form below must be filled out.

Here's why we have that policy: TensorFlow developers respond to issues. We want to focus on work that benefits the whole community, e.g., fixing bugs and adding features. Support only helps individuals. GitHub also notifies thousands of people when issues are filed. We want them to see you communicating an interesting problem, rather than being redirected to Stack Overflow.

System information

What is the top-level directory of the model you are using:E:
Have I written custom code (as opposed to using a stock example script provided in TensorFlow):No
OS Platform and Distribution (e.g., Linux Ubuntu 16.04):win10
TensorFlow installed from (source or binary):binary
TensorFlow version (use command below):1.6
Bazel version (if compiling from source):
CUDA/cuDNN version:8.0
GPU model and memory:use CPU
Exact command to reproduce:

You can collect some of this information using our environment capture script:

https://github.com/tensorflow/tensorflow/tree/master/tools/tf_env_collect.sh

You can obtain the TensorFlow version with

python -c "import tensorflow as tf; print(tf.GIT_VERSION, tf.VERSION)"

Describe the problem

Describe the problem clearly here. Be sure to convey here why it's a bug in TensorFlow or a feature request.

Source code / logs

Include any logs or source code that would be helpful to diagnose the problem. If including tracebacks, please include the full traceback. Large logs and files should be attached. Try to provide a reproducible test case that is the bare minimum necessary to generate the problem.

test the train result,report google.protobuf.message.DecodeError: Truncated message.
error detainls are as follow:
E:Python36python.exe "C:Program FilesJetBrainsPyCharm 2018.2helperspydevpydevconsole.py" 52401 52402
import sys; print('Python %s on %s' % (sys.version, sys.platform))
sys.path.extend(['E:\raccoon', 'E:/raccoon'])
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:54:40) [MSC v.1900 64 bit (AMD64)]
Type 'copyright', 'credits' or 'license' for more information
IPython 6.4.0 -- An enhanced Interactive Python. Type '?' for help.
PyDev console: using IPython 6.4.0
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:54:40) [MSC v.1900 64 bit (AMD64)] on win32
runfile('E:/raccoon/test.py', wdir='E:/raccoon')
Traceback (most recent call last):
File "E:Python36libsite-packagesIPythoncoreinteractiveshell.py", line 2963, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "", line 1, in
runfile('E:/raccoon/test.py', wdir='E:/raccoon')
File "C:Program FilesJetBrainsPyCharm 2018.2helperspydev_pydev_bundlepydev_umd.py", line 194, in runfile
pydev_imports.execfile(filename, global_vars, local_vars) # execute the script
File "C:Program FilesJetBrainsPyCharm 2018.2helperspydev_pydev_imps_pydev_execfile.py", line 18, in execfile
exec(compile(contents+"n", file, 'exec'), glob, loc)
File "E:/raccoon/test.py", line 75, in
detecotr = TOD()
File "E:/raccoon/test.py", line 23, in __init__
self.detection_graph = self._load_model()
File "E:/raccoon/test.py", line 32, in _load_model
od_graph_def.ParseFromString(serialized_graph)
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufmessage.py", line 185, in ParseFromString
self.MergeFromString(serialized)
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternalpython_message.py", line 1069, in MergeFromString
if self._InternalParse(serialized, 0, length) != length:
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternalpython_message.py", line 1105, in InternalParse
pos = field_decoder(buffer, new_pos, end, self, field_dict)
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternaldecoder.py", line 633, in DecodeField
if value._InternalParse(buffer, pos, new_pos) != new_pos:
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternalpython_message.py", line 1105, in InternalParse
pos = field_decoder(buffer, new_pos, end, self, field_dict)
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternaldecoder.py", line 612, in DecodeRepeatedField
if value.add()._InternalParse(buffer, pos, new_pos) != new_pos:
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternalpython_message.py", line 1105, in InternalParse
pos = field_decoder(buffer, new_pos, end, self, field_dict)
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternaldecoder.py", line 743, in DecodeMap
if submsg._InternalParse(buffer, pos, new_pos) != new_pos:
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternalpython_message.py", line 1095, in InternalParse
new_pos = local_SkipField(buffer, new_pos, end, tag_bytes)
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternaldecoder.py", line 850, in SkipField
return WIRETYPE_TO_SKIPPERwire_type
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternaldecoder.py", line 799, in _SkipGroup
new_pos = SkipField(buffer, pos, end, tag_bytes)
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternaldecoder.py", line 850, in SkipField
return WIRETYPE_TO_SKIPPERwire_type
File "E:Python36libsite-packagesprotobuf-3.4.0-py3.6.egggoogleprotobufinternaldecoder.py", line 814, in _SkipFixed32
raise _DecodeError('Truncated message.')
google.protobuf.message.DecodeError: Truncated message.

there are the detail of related file:
decoder.py:

Protocol Buffers - Google's data interchange format

Copyright 2008 Google Inc. All rights reserved.

https://developers.google.com/protocol-buffers/

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are

met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following disclaimer

in the documentation and/or other materials provided with the

distribution.

* Neither the name of Google Inc. nor the names of its

contributors may be used to endorse or promote products derived from

this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

"""Code for decoding protocol buffer primitives.

This code is very similar to encoder.py -- read the docs for that module first.

A "decoder" is a function with the signature:
Decode(buffer, pos, end, message, field_dict)
The arguments are:
buffer: The string containing the encoded message.
pos: The current position in the string.
end: The position in the string where the current message ends. May be
less than len(buffer) if we're reading a sub-message.
message: The message object into which we're parsing.
field_dict: message._fields (avoids a hashtable lookup).
The decoder reads the field and stores it into field_dict, returning the new
buffer position. A decoder for a repeated field may proactively decode all of
the elements of that field, if they appear consecutively.

Note that decoders may throw any of the following:
IndexError: Indicates a truncated message.
struct.error: Unpacking of a fixed-width field failed.
message.DecodeError: Other errors.

Decoders are expected to raise an exception if they are called with pos > end.
This allows callers to be lax about bounds checking: it's fineto read past
"end" as long as you are sure that someone else will notice and throw an
exception later on.

Something up the call stack is expected to catch IndexError and struct.error
and convert them to message.DecodeError.

Decoders are constructed using decoder constructors with the signature:
MakeDecoder(field_number, is_repeated, is_packed, key, new_default)
The arguments are:
field_number: The field number of the field we want to decode.
is_repeated: Is the field a repeated field? (bool)
is_packed: Is the field a packed field? (bool)
key: The key to use when looking up the field within field_dict.
(This is actually the FieldDescriptor but nothing in this
file should depend on that.)
new_default: A function which takes a message object as a parameter and
returns a new instance of the default value for this field.
(This is called for repeated fields and sub-messages, when an
instance does not already exist.)

As with encoders, we define a decoder constructor for every type of field.
Then, for every field of every message class we construct an actual decoder.
That decoder goes into a dict indexed by tag, so when we decode a message
we repeatedly read a tag, look up the corresponding decoder, and invoke it.
"""

__author__ = '[email protected] (Kenton Varda)'

import struct

import six

if six.PY3:
long = int

from google.protobuf.internal import encoder
from google.protobuf.internal import wire_format
from google.protobuf import message

This will overflow and thus become IEEE-754 "infinity". We would use

"float('inf')" but it doesn't work on Windows pre-Python-2.6.

_POS_INF = 1e10000
_NEG_INF = -_POS_INF
_NAN = _POS_INF * 0

This is not for optimization, but rather to avoid conflicts with local

variables named "message".

_DecodeError = message.DecodeError

def _VarintDecoder(mask, result_type):
"""Return an encoder for a basic varint value (does not include tag).

Decoded values will be bitwise-anded with the given mask before being
returned, e.g. to limit them to 32 bits. The returned decoder does not
take the usual "end" parameter -- the caller is expected to do bounds checking
after the fact (often the caller can defer such checking until later). The
decoder returns a (value, new_pos) pair.
"""

def DecodeVarint(buffer, pos):
result = 0
shift = 0
while 1:
b = six.indexbytes(buffer, pos)
result |= ((b & 0x7f) << shift)
pos += 1
if not (b & 0x80):
result &= mask
result = result_type(result)
return (result, pos)
shift += 7
if shift >= 64:
raise _DecodeError('Too many bytes when decoding varint.')
return DecodeVarint

def _SignedVarintDecoder(bits, result_type):
"""Like _VarintDecoder() but decodes signed values."""

signbit = 1 << (bits - 1)
mask = (1 << bits) - 1

def DecodeVarint(buffer, pos):
result = 0
shift = 0
while 1:
b = six.indexbytes(buffer, pos)
result |= ((b & 0x7f) << shift)
pos += 1
if not (b & 0x80):
result &= mask
result = (result ^ signbit) - signbit
result = result_type(result)
return (result, pos)
shift += 7
if shift >= 64:
raise _DecodeError('Too many bytes when decoding varint.')
return DecodeVarint

We force 32-bit values to int and 64-bit values to long to make

alternate implementations where the distinction is more significant

(e.g. the C++ implementation) simpler.

_DecodeVarint = _VarintDecoder((1 << 64) - 1, int)
_DecodeSignedVarint = _SignedVarintDecoder(64, int)

Use these versions for values which must be limited to 32 bits.

_DecodeVarint32 = _VarintDecoder((1 << 32) - 1, int)
_DecodeSignedVarint32 = _SignedVarintDecoder(32, int)

def ReadTag(buffer, pos):
"""Read a tag from the buffer, and return a (tag_bytes, new_pos) tuple.

We return the raw bytes of the tag rather than decoding them. The raw
bytes can then be used to look up the proper decoder. This effectively allows
us to trade some work that would be done in pure-python (decoding a varint)
for work that is done in C (searching for a byte string in a hash table).
In a low-level language it would be much cheaper to decode the varint and
use that, but not in Python.
"""

start = pos
while six.indexbytes(buffer, pos) & 0x80:
pos += 1
pos += 1
return (buffer[start:pos], pos)

--------------------------------------------------------------------

def _SimpleDecoder(wire_type, decode_value):
"""Return a constructor for a decoder for fields of a particular type.

Args:
wire_type: The field's wire type.
decode_value: A function which decodes an individual value, e.g.
_DecodeVarint()
"""

def SpecificDecoder(field_number, is_repeated, is_packed, key, new_default):
if is_packed:
local_DecodeVarint = _DecodeVarint
def DecodePackedField(buffer, pos, end, message, field_dict):
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
(endpoint, pos) = local_DecodeVarint(buffer, pos)
endpoint += pos
if endpoint > end:
raise _DecodeError('Truncated message.')
while pos < endpoint:
(element, pos) = decode_value(buffer, pos)
value.append(element)
if pos > endpoint:
del value[-1] # Discard corrupt value.
raise _DecodeError('Packed element was truncated.')
return pos
return DecodePackedField
elif is_repeated:
tag_bytes = encoder.TagBytes(field_number, wire_type)
tag_len = len(tag_bytes)
def DecodeRepeatedField(buffer, pos, end, message, field_dict):
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
while 1:
(element, new_pos) = decode_value(buffer, pos)
value.append(element)
# Predict that the next tag is another copy of the same repeated
# field.
pos = new_pos + tag_len
if buffer[new_pos:pos] != tag_bytes or new_pos >= end:
# Prediction failed. Return.
if new_pos > end:
raise _DecodeError('Truncated message.')
return new_pos
return DecodeRepeatedField
else:
def DecodeField(buffer, pos, end, message, field_dict):
(field_dict[key], pos) = decode_value(buffer, pos)
if pos > end:
del field_dict[key] # Discard corrupt value.
raise _DecodeError('Truncated message.')
return pos
return DecodeField

return SpecificDecoder

def _ModifiedDecoder(wire_type, decode_value, modify_value):
"""Like SimpleDecoder but additionally invokes modify_value on every value
before storing it. Usually modify_value is ZigZagDecode.
"""

# Reusing _SimpleDecoder is slightly slower than copying a bunch of code, but
# not enough to make a significant difference.

def InnerDecode(buffer, pos):
(result, new_pos) = decode_value(buffer, pos)
return (modify_value(result), new_pos)
return _SimpleDecoder(wire_type, InnerDecode)

def _StructPackDecoder(wire_type, format):
"""Return a constructor for a decoder for a fixed-width field.

Args:
wire_type: The field's wire type.
format: The format string to pass to struct.unpack().
"""

value_size = struct.calcsize(format)
local_unpack = struct.unpack

# Reusing _SimpleDecoder is slightly slower than copying a bunch of code, but
# not enough to make a significant difference.

# Note that we expect someone up-stack to catch struct.error and convert
# it to _DecodeError -- this way we don't have to set up exception-
# handling blocks every time we parse one value.

def InnerDecode(buffer, pos):
new_pos = pos + value_size
result = local_unpack(format, buffer[pos:new_pos])[0]
return (result, new_pos)
return _SimpleDecoder(wire_type, InnerDecode)

def _FloatDecoder():
"""Returns a decoder for a float field.

This code works around a bug in struct.unpack for non-finite 32-bit
floating-point values.
"""

local_unpack = struct.unpack

def InnerDecode(buffer, pos):
# We expect a 32-bit value in little-endian byte order. Bit 1 is the sign
# bit, bits 2-9 represent the exponent, and bits 10-32 are the significand.
new_pos = pos + 4
float_bytes = buffer[pos:new_pos]

# If this value has all its exponent bits set, then it's non-finite.
# In Python 2.4, struct.unpack will convert it to a finite 64-bit value.
# To avoid that, we parse it specially.
if (float_bytes[3:4] in b'\x7F\xFF' and float_bytes[2:3] >= b'\x80'):
  # If at least one significand bit is set...
  if float_bytes[0:3] != b'\x00\x00\x80':
    return (_NAN, new_pos)
  # If sign bit is set...
  if float_bytes[3:4] == b'\xFF':
    return (_NEG_INF, new_pos)
  return (_POS_INF, new_pos)

# Note that we expect someone up-stack to catch struct.error and convert
# it to _DecodeError -- this way we don't have to set up exception-
# handling blocks every time we parse one value.
result = local_unpack('<f', float_bytes)[0]
return (result, new_pos)

return _SimpleDecoder(wire_format.WIRETYPE_FIXED32, InnerDecode)

def _DoubleDecoder():
"""Returns a decoder for a double field.

This code works around a bug in struct.unpack for not-a-number.
"""

local_unpack = struct.unpack

def InnerDecode(buffer, pos):
# We expect a 64-bit value in little-endian byte order. Bit 1 is the sign
# bit, bits 2-12 represent the exponent, and bits 13-64 are the significand.
new_pos = pos + 8
double_bytes = buffer[pos:new_pos]

# If this value has all its exponent bits set and at least one significand
# bit set, it's not a number.  In Python 2.4, struct.unpack will treat it
# as inf or -inf.  To avoid that, we treat it specially.
if ((double_bytes[7:8] in b'\x7F\xFF')
    and (double_bytes[6:7] >= b'\xF0')
    and (double_bytes[0:7] != b'\x00\x00\x00\x00\x00\x00\xF0')):
  return (_NAN, new_pos)

# Note that we expect someone up-stack to catch struct.error and convert
# it to _DecodeError -- this way we don't have to set up exception-
# handling blocks every time we parse one value.
result = local_unpack('<d', double_bytes)[0]
return (result, new_pos)

return _SimpleDecoder(wire_format.WIRETYPE_FIXED64, InnerDecode)

def EnumDecoder(field_number, is_repeated, is_packed, key, new_default):
enum_type = key.enum_type
if is_packed:
local_DecodeVarint = _DecodeVarint
def DecodePackedField(buffer, pos, end, message, field_dict):
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
(endpoint, pos) = local_DecodeVarint(buffer, pos)
endpoint += pos
if endpoint > end:
raise _DecodeError('Truncated message.')
while pos < endpoint:
value_start_pos = pos
(element, pos) = _DecodeSignedVarint32(buffer, pos)
if element in enum_type.values_by_number:
value.append(element)
else:
if not message._unknown_fields:
message._unknown_fields = []
tag_bytes = encoder.TagBytes(field_number,
wire_format.WIRETYPE_VARINT)
message._unknown_fields.append(
(tag_bytes, buffer[value_start_pos:pos]))
if pos > endpoint:
if element in enum_type.values_by_number:
del value[-1] # Discard corrupt value.
else:
del message._unknown_fields[-1]
raise _DecodeError('Packed element was truncated.')
return pos
return DecodePackedField
elif is_repeated:
tag_bytes = encoder.TagBytes(field_number, wire_format.WIRETYPE_VARINT)
tag_len = len(tag_bytes)
def DecodeRepeatedField(buffer, pos, end, message, field_dict):
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
while 1:
(element, new_pos) = _DecodeSignedVarint32(buffer, pos)
if element in enum_type.values_by_number:
value.append(element)
else:
if not message._unknown_fields:
message._unknown_fields = []
message._unknown_fields.append(
(tag_bytes, buffer[pos:new_pos]))
# Predict that the next tag is another copy of the same repeated
# field.
pos = new_pos + tag_len
if buffer[new_pos:pos] != tag_bytes or new_pos >= end:
# Prediction failed. Return.
if new_pos > end:
raise _DecodeError('Truncated message.')
return new_pos
return DecodeRepeatedField
else:
def DecodeField(buffer, pos, end, message, field_dict):
value_start_pos = pos
(enum_value, pos) = _DecodeSignedVarint32(buffer, pos)
if pos > end:
raise _DecodeError('Truncated message.')
if enum_value in enum_type.values_by_number:
field_dict[key] = enum_value
else:
if not message._unknown_fields:
message._unknown_fields = []
tag_bytes = encoder.TagBytes(field_number,
wire_format.WIRETYPE_VARINT)
message._unknown_fields.append(
(tag_bytes, buffer[value_start_pos:pos]))
return pos
return DecodeField

--------------------------------------------------------------------

Int32Decoder = _SimpleDecoder(
wire_format.WIRETYPE_VARINT, _DecodeSignedVarint32)

Int64Decoder = _SimpleDecoder(
wire_format.WIRETYPE_VARINT, _DecodeSignedVarint)

UInt32Decoder = _SimpleDecoder(wire_format.WIRETYPE_VARINT, _DecodeVarint32)
UInt64Decoder = _SimpleDecoder(wire_format.WIRETYPE_VARINT, _DecodeVarint)

SInt32Decoder = _ModifiedDecoder(
wire_format.WIRETYPE_VARINT, _DecodeVarint32, wire_format.ZigZagDecode)
SInt64Decoder = _ModifiedDecoder(
wire_format.WIRETYPE_VARINT, _DecodeVarint, wire_format.ZigZagDecode)

Note that Python conveniently guarantees that when using the '<' prefix on

formats, they will also have the same size across all platforms (as opposed

to without the prefix, where their sizes depend on the C compiler's basic

type sizes).

Fixed32Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED32, ' Fixed64Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED64, ' SFixed32Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED32, ' SFixed64Decoder = _StructPackDecoder(wire_format.WIRETYPE_FIXED64, ' FloatDecoder = _FloatDecoder()
DoubleDecoder = _DoubleDecoder()

BoolDecoder = _ModifiedDecoder(
wire_format.WIRETYPE_VARINT, _DecodeVarint, bool)

def StringDecoder(field_number, is_repeated, is_packed, key, new_default):
"""Returns a decoder for a string field."""

local_DecodeVarint = _DecodeVarint
local_unicode = six.text_type

def _ConvertToUnicode(byte_str):
try:
return local_unicode(byte_str, 'utf-8')
except UnicodeDecodeError as e:
# add more information to the error message and re-raise it.
e.reason = '%s in field: %s' % (e, key.full_name)
raise

def BytesDecoder(field_number, is_repeated, is_packed, key, new_default):
"""Returns a decoder for a bytes field."""

local_DecodeVarint = _DecodeVarint

def GroupDecoder(field_number, is_repeated, is_packed, key, new_default):
"""Returns a decoder for a group field."""

end_tag_bytes = encoder.TagBytes(field_number,
wire_format.WIRETYPE_END_GROUP)
end_tag_len = len(end_tag_bytes)

assert not is_packed
if is_repeated:
tag_bytes = encoder.TagBytes(field_number,
wire_format.WIRETYPE_START_GROUP)
tag_len = len(tag_bytes)
def DecodeRepeatedField(buffer, pos, end, message, field_dict):
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
while 1:
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
# Read sub-message.
pos = value.add()._InternalParse(buffer, pos, end)
# Read end tag.
new_pos = pos+end_tag_len
if buffer[pos:new_pos] != end_tag_bytes or new_pos > end:
raise _DecodeError('Missing group end tag.')
# Predict that the next tag is another copy of the same repeated field.
pos = new_pos + tag_len
if buffer[new_pos:pos] != tag_bytes or new_pos == end:
# Prediction failed. Return.
return new_pos
return DecodeRepeatedField
else:
def DecodeField(buffer, pos, end, message, field_dict):
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
# Read sub-message.
pos = value._InternalParse(buffer, pos, end)
# Read end tag.
new_pos = pos+end_tag_len
if buffer[pos:new_pos] != end_tag_bytes or new_pos > end:
raise _DecodeError('Missing group end tag.')
return new_pos
return DecodeField

def MessageDecoder(field_number, is_repeated, is_packed, key, new_default):
"""Returns a decoder for a message field."""

local_DecodeVarint = _DecodeVarint

assert not is_packed
if is_repeated:
tag_bytes = encoder.TagBytes(field_number,
wire_format.WIRETYPE_LENGTH_DELIMITED)
tag_len = len(tag_bytes)
def DecodeRepeatedField(buffer, pos, end, message, field_dict):
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
while 1:
# Read length.
(size, pos) = local_DecodeVarint(buffer, pos)
new_pos = pos + size
if new_pos > end:
raise _DecodeError('Truncated message.')
# Read sub-message.
if value.add()._InternalParse(buffer, pos, new_pos) != new_pos:
# The only reason _InternalParse would return early is if it
# encountered an end-group tag.
raise _DecodeError('Unexpected end-group tag.')
# Predict that the next tag is another copy of the same repeated field.
pos = new_pos + tag_len
if buffer[new_pos:pos] != tag_bytes or new_pos == end:
# Prediction failed. Return.
return new_pos
return DecodeRepeatedField
else:
def DecodeField(buffer, pos, end, message, field_dict):
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
# Read length.
(size, pos) = local_DecodeVarint(buffer, pos)
new_pos = pos + size
if new_pos > end:
raise _DecodeError('Truncated message.')
# Read sub-message.
if value._InternalParse(buffer, pos, new_pos) != new_pos:
# The only reason _InternalParse would return early is if it encountered
# an end-group tag.
raise _DecodeError('Unexpected end-group tag.')
return new_pos
return DecodeField

--------------------------------------------------------------------

MESSAGE_SET_ITEM_TAG = encoder.TagBytes(1, wire_format.WIRETYPE_START_GROUP)

def MessageSetItemDecoder(descriptor):
"""Returns a decoder for a MessageSet item.

The parameter is the message Descriptor.

The message set message looks like this:
message MessageSet {
repeated group Item = 1 {
required int32 type_id = 2;
required string message = 3;
}
}
"""

type_id_tag_bytes = encoder.TagBytes(2, wire_format.WIRETYPE_VARINT)
message_tag_bytes = encoder.TagBytes(3, wire_format.WIRETYPE_LENGTH_DELIMITED)
item_end_tag_bytes = encoder.TagBytes(1, wire_format.WIRETYPE_END_GROUP)

local_ReadTag = ReadTag
local_DecodeVarint = _DecodeVarint
local_SkipField = SkipField

def DecodeItem(buffer, pos, end, message, field_dict):
message_set_item_start = pos
type_id = -1
message_start = -1
message_end = -1

# Technically, type_id and message can appear in any order, so we need
# a little loop here.
while 1:
  (tag_bytes, pos) = local_ReadTag(buffer, pos)
  if tag_bytes == type_id_tag_bytes:
    (type_id, pos) = local_DecodeVarint(buffer, pos)
  elif tag_bytes == message_tag_bytes:
    (size, message_start) = local_DecodeVarint(buffer, pos)
    pos = message_end = message_start + size
  elif tag_bytes == item_end_tag_bytes:
    break
  else:
    pos = SkipField(buffer, pos, end, tag_bytes)
    if pos == -1:
      raise _DecodeError('Missing group end tag.')

if pos > end:
  raise _DecodeError('Truncated message.')

if type_id == -1:
  raise _DecodeError('MessageSet item missing type_id.')
if message_start == -1:
  raise _DecodeError('MessageSet item missing message.')

extension = message.Extensions._FindExtensionByNumber(type_id)
if extension is not None:
  value = field_dict.get(extension)
  if value is None:
    value = field_dict.setdefault(
        extension, extension.message_type._concrete_class())
  if value._InternalParse(buffer, message_start,message_end) != message_end:
    # The only reason _InternalParse would return early is if it encountered
    # an end-group tag.
    raise _DecodeError('Unexpected end-group tag.')
else:
  if not message._unknown_fields:
    message._unknown_fields = []
  message._unknown_fields.append((MESSAGE_SET_ITEM_TAG,
                                  buffer[message_set_item_start:pos]))

return pos

return DecodeItem

--------------------------------------------------------------------

def MapDecoder(field_descriptor, new_default, is_message_map):
"""Returns a decoder for a map field."""

key = field_descriptor
tag_bytes = encoder.TagBytes(field_descriptor.number,
wire_format.WIRETYPE_LENGTH_DELIMITED)
tag_len = len(tag_bytes)
local_DecodeVarint = _DecodeVarint
# Can't read _concrete_class yet; might not be initialized.
message_type = field_descriptor.message_type

def DecodeMap(buffer, pos, end, message, field_dict):
submsg = message_type._concrete_class()
value = field_dict.get(key)
if value is None:
value = field_dict.setdefault(key, new_default(message))
while 1:
# Read length.
(size, pos) = local_DecodeVarint(buffer, pos)
new_pos = pos + size
if new_pos > end:
raise _DecodeError('Truncated message.')
# Read sub-message.
submsg.Clear()
if submsg._InternalParse(buffer, pos, new_pos) != new_pos:
# The only reason _InternalParse would return early is if it
# encountered an end-group tag.
raise _DecodeError('Unexpected end-group tag.')

  if is_message_map:
    value[submsg.key].MergeFrom(submsg.value)
  else:
    value[submsg.key] = submsg.value

  # Predict that the next tag is another copy of the same repeated field.
  pos = new_pos + tag_len
  if buffer[new_pos:pos] != tag_bytes or new_pos == end:
    # Prediction failed.  Return.
    return new_pos

return DecodeMap

--------------------------------------------------------------------

Optimization is not as heavy here because calls to SkipField() are rare,

except for handling end-group tags.

def _SkipVarint(buffer, pos, end):
"""Skip a varint value. Returns the new position."""
# Previously ord(buffer[pos]) raised IndexError when pos is out of range.
# With this code, ord(b'') raises TypeError. Both are handled in
# python_message.py to generate a 'Truncated message' error.
while ord(buffer[pos:pos+1]) & 0x80:
pos += 1
pos += 1
if pos > end:
raise _DecodeError('Truncated message.')
return pos

def _SkipFixed64(buffer, pos, end):
"""Skip a fixed64 value. Returns the new position."""

pos += 8
if pos > end:
raise _DecodeError('Truncated message.')
return pos

def _SkipLengthDelimited(buffer, pos, end):
"""Skip a length-delimited value. Returns the new position."""

(size, pos) = _DecodeVarint(buffer, pos)
pos += size
if pos > end:
raise _DecodeError('Truncated message.')
return pos

def _SkipGroup(buffer, pos, end):
"""Skip sub-group. Returns the new position."""

while 1:
(tag_bytes, pos) = ReadTag(buffer, pos)
new_pos = SkipField(buffer, pos, end, tag_bytes)
if new_pos == -1:
return pos
pos = new_pos

def _EndGroup(buffer, pos, end):
"""Skipping an END_GROUP tag returns -1 to tell the parent loop to break."""

return -1

def _SkipFixed32(buffer, pos, end):
"""Skip a fixed32 value. Returns the new position."""

pos += 4
if pos > end:
raise _DecodeError('Truncated message.')
return pos

def _RaiseInvalidWireType(buffer, pos, end):
"""Skip function for unknown wire types. Raises an exception."""

raise _DecodeError('Tag had invalid wire type.')

def _FieldSkipper():
"""Constructs the SkipField function."""

WIRETYPE_TO_SKIPPER = [
_SkipVarint,
_SkipFixed64,
_SkipLengthDelimited,
_SkipGroup,
_EndGroup,
_SkipFixed32,
_RaiseInvalidWireType,
_RaiseInvalidWireType,
]

wiretype_mask = wire_format.TAG_TYPE_MASK

def SkipField(buffer, pos, end, tag_bytes):
"""Skips a field with the specified tag.

|pos| should point to the byte immediately after the tag.

Returns:
    The new position (after the tag value), or -1 if the tag is an end-group
    tag (in which case the calling loop should break).
"""

# The wire type is always in the first byte since varints are little-endian.
wire_type = ord(tag_bytes[0:1]) & wiretype_mask
return WIRETYPE_TO_SKIPPER[wire_type](buffer, pos, end)

return SkipField

SkipField = _FieldSkipper()

Source

Distance789

Most helpful comment

So bad question.

SubWayss on 8 Aug 2018

😄2 😕1

All 2 comments

So bad question.

SubWayss on 8 Aug 2018

😄2 😕1

Hi There,
We are checking to see if you still need help on this, as this seems to be considerably old issue. Please update this issue with the latest information, code snippet to reproduce your issue and error you are seeing.
If we don't hear from you in the next 7 days, this issue will be closed automatically. If you don't need help on this issue any more, please consider closing this.