new mcp servers format

.venv/lib/python3.10/site-packages/google/protobuf/internal/decoder.py

@@ -58,7 +58,6 @@ we repeatedly read a tag, look up the corresponding decoder, and invoke it.
 __author__ = 'kenton@google.com (Kenton Varda)'
 
 import math
-import numbers
 import struct
 
 from google.protobuf import message
@@ -72,27 +71,6 @@ from google.protobuf.internal import wire_format
 _DecodeError = message.DecodeError
 
 
-def IsDefaultScalarValue(value):
-  """Returns whether or not a scalar value is the default value of its type.
-
-  Specifically, this should be used to determine presence of implicit-presence
-  fields, where we disallow custom defaults.
-
-  Args:
-    value: A scalar value to check.
-
-  Returns:
-    True if the value is equivalent to a default value, False otherwise.
-  """
-  if isinstance(value, numbers.Number) and math.copysign(1.0, value) < 0:
-    # Special case for negative zero, where "truthiness" fails to give the right
-    # answer.
-    return False
-
-  # Normally, we can just use Python's boolean conversion.
-  return not value
-
-
 def _VarintDecoder(mask, result_type):
   """Return an encoder for a basic varint value (does not include tag).
 
@@ -190,19 +168,6 @@ def ReadTag(buffer, pos):
   return tag_bytes, pos
 
 
-def DecodeTag(tag_bytes):
-  """Decode a tag from the bytes.
-
-  Args:
-    tag_bytes: the bytes of the tag
-
-  Returns:
-    Tuple[int, int] of the tag field number and wire type.
-  """
-  (tag, _) = _DecodeVarint(tag_bytes, 0)
-  return wire_format.UnpackTag(tag)
-
-
 # --------------------------------------------------------------------
 
 
@@ -259,7 +224,7 @@ def _SimpleDecoder(wire_type, decode_value):
         (new_value, pos) = decode_value(buffer, pos)
         if pos > end:
           raise _DecodeError('Truncated message.')
-        if clear_if_default and IsDefaultScalarValue(new_value):
+        if clear_if_default and not new_value:
           field_dict.pop(key, None)
         else:
           field_dict[key] = new_value
@@ -500,7 +465,7 @@ def EnumDecoder(field_number, is_repeated, is_packed, key, new_default,
       (enum_value, pos) = _DecodeSignedVarint32(buffer, pos)
       if pos > end:
         raise _DecodeError('Truncated message.')
-      if clear_if_default and IsDefaultScalarValue(enum_value):
+      if clear_if_default and not enum_value:
         field_dict.pop(key, None)
         return pos
       # pylint: disable=protected-access
@@ -595,7 +560,7 @@ def StringDecoder(field_number, is_repeated, is_packed, key, new_default,
       new_pos = pos + size
       if new_pos > end:
         raise _DecodeError('Truncated string.')
-      if clear_if_default and IsDefaultScalarValue(size):
+      if clear_if_default and not size:
         field_dict.pop(key, None)
       else:
         field_dict[key] = _ConvertToUnicode(buffer[pos:new_pos])
@@ -636,7 +601,7 @@ def BytesDecoder(field_number, is_repeated, is_packed, key, new_default,
       new_pos = pos + size
       if new_pos > end:
         raise _DecodeError('Truncated string.')
-      if clear_if_default and IsDefaultScalarValue(size):
+      if clear_if_default and not size:
         field_dict.pop(key, None)
       else:
         field_dict[key] = buffer[pos:new_pos].tobytes()
@@ -765,6 +730,7 @@ def MessageSetItemDecoder(descriptor):
 
   local_ReadTag = ReadTag
   local_DecodeVarint = _DecodeVarint
+  local_SkipField = SkipField
 
   def DecodeItem(buffer, pos, end, message, field_dict):
     """Decode serialized message set to its value and new position.
@@ -796,10 +762,9 @@ def MessageSetItemDecoder(descriptor):
       elif tag_bytes == item_end_tag_bytes:
         break
       else:
-        field_number, wire_type = DecodeTag(tag_bytes)
-        _, pos = _DecodeUnknownField(buffer, pos, end, field_number, wire_type)
+        pos = SkipField(buffer, pos, end, tag_bytes)
         if pos == -1:
-          raise _DecodeError('Unexpected end-group tag.')
+          raise _DecodeError('Missing group end tag.')
 
     if pos > end:
       raise _DecodeError('Truncated message.')
@@ -857,10 +822,9 @@ def UnknownMessageSetItemDecoder():
       elif tag_bytes == item_end_tag_bytes:
         break
       else:
-        field_number, wire_type = DecodeTag(tag_bytes)
-        _, pos = _DecodeUnknownField(buffer, pos, end, field_number, wire_type)
+        pos = SkipField(buffer, pos, end, tag_bytes)
         if pos == -1:
-          raise _DecodeError('Unexpected end-group tag.')
+          raise _DecodeError('Missing group end tag.')
 
     if pos > end:
       raise _DecodeError('Truncated message.')
@@ -918,6 +882,30 @@ def MapDecoder(field_descriptor, new_default, is_message_map):
 
   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].tobytes()) & 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 _DecodeFixed64(buffer, pos):
   """Decode a fixed64."""
@@ -925,11 +913,25 @@ def _DecodeFixed64(buffer, pos):
   return (struct.unpack('<Q', buffer[pos:new_pos])[0], new_pos)
 
 
-def _DecodeFixed32(buffer, pos):
-  """Decode a fixed32."""
+def _SkipLengthDelimited(buffer, pos, end):
+  """Skip a length-delimited value.  Returns the new position."""
 
-  new_pos = pos + 4
-  return (struct.unpack('<I', buffer[pos:new_pos])[0], new_pos)
+  (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 _DecodeUnknownFieldSet(buffer, pos, end_pos=None):
@@ -942,16 +944,14 @@ def _DecodeUnknownFieldSet(buffer, pos, end_pos=None):
     field_number, wire_type = wire_format.UnpackTag(tag)
     if wire_type == wire_format.WIRETYPE_END_GROUP:
       break
-    (data, pos) = _DecodeUnknownField(
-        buffer, pos, end_pos, field_number, wire_type
-    )
+    (data, pos) = _DecodeUnknownField(buffer, pos, wire_type)
     # pylint: disable=protected-access
     unknown_field_set._add(field_number, wire_type, data)
 
   return (unknown_field_set, pos)
 
 
-def _DecodeUnknownField(buffer, pos, end_pos, field_number, wire_type):
+def _DecodeUnknownField(buffer, pos, wire_type):
   """Decode a unknown field.  Returns the UnknownField and new position."""
 
   if wire_type == wire_format.WIRETYPE_VARINT:
@@ -965,19 +965,72 @@ def _DecodeUnknownField(buffer, pos, end_pos, field_number, wire_type):
     data = buffer[pos:pos+size].tobytes()
     pos += size
   elif wire_type == wire_format.WIRETYPE_START_GROUP:
-    end_tag_bytes = encoder.TagBytes(
-        field_number, wire_format.WIRETYPE_END_GROUP
-    )
-    data, pos = _DecodeUnknownFieldSet(buffer, pos, end_pos)
-    # Check end tag.
-    if buffer[pos - len(end_tag_bytes) : pos] != end_tag_bytes:
-      raise _DecodeError('Missing group end tag.')
+    (data, pos) = _DecodeUnknownFieldSet(buffer, pos)
   elif wire_type == wire_format.WIRETYPE_END_GROUP:
     return (0, -1)
   else:
     raise _DecodeError('Wrong wire type in tag.')
 
-  if pos > end_pos:
-    raise _DecodeError('Truncated message.')
-
   return (data, 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 _DecodeFixed32(buffer, pos):
+  """Decode a fixed32."""
+
+  new_pos = pos + 4
+  return (struct.unpack('<I', buffer[pos:new_pos])[0], new_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()