protobuf 5.29.4__py3-none-any.whl → 6.33.3__py3-none-any.whl

google/protobuf/internal/well_known_types.py

@@ -20,13 +20,13 @@ __author__ = 'jieluo@google.com (Jie Luo)'
 import calendar
 import collections.abc
 import datetime
+from typing import Union
 import warnings
 from google.protobuf.internal import field_mask
-from typing import Union
 
 FieldMask = field_mask.FieldMask
 
-_TIMESTAMPFOMAT = '%Y-%m-%dT%H:%M:%S'
+_TIMESTAMPFORMAT = '%Y-%m-%dT%H:%M:%S'
 _NANOS_PER_SECOND = 1000000000
 _NANOS_PER_MILLISECOND = 1000000
 _NANOS_PER_MICROSECOND = 1000
@@ -48,8 +48,9 @@ class Any(object):
 
   __slots__ = ()
 
-  def Pack(self, msg, type_url_prefix='type.googleapis.com/',
-           deterministic=None):
+  def Pack(
+      self, msg, type_url_prefix='type.googleapis.com/', deterministic=None
+  ):
     """Packs the specified message into current Any message."""
     if len(type_url_prefix) < 1 or type_url_prefix[-1] != '/':
       self.type_url = '%s/%s' % (type_url_prefix, msg.DESCRIPTOR.full_name)
@@ -68,7 +69,7 @@ class Any(object):
   def TypeName(self):
     """Returns the protobuf type name of the inner message."""
     # Only last part is to be used: b/25630112
-    return self.type_url.split('/')[-1]
+    return self.type_url.rpartition('/')[2]
 
   def Is(self, descriptor):
     """Checks if this Any represents the given protobuf type."""
@@ -113,8 +114,8 @@ class Timestamp(object):
 
     Args:
       value: A date string. Any fractional digits (or none) and any offset are
-          accepted as long as they fit into nano-seconds precision.
-          Example of accepted format: '1972-01-01T10:00:20.021-05:00'
+        accepted as long as they fit into nano-seconds precision. Example of
+        accepted format: '1972-01-01T10:00:20.021-05:00'
 
     Raises:
       ValueError: On parsing problems.
@@ -128,7 +129,8 @@ class Timestamp(object):
       timezone_offset = value.rfind('-')
     if timezone_offset == -1:
       raise ValueError(
-          'Failed to parse timestamp: missing valid timezone offset.')
+          'Failed to parse timestamp: missing valid timezone offset.'
+      )
     time_value = value[0:timezone_offset]
     # Parse datetime and nanos.
     point_position = time_value.find('.')
@@ -137,18 +139,20 @@ class Timestamp(object):
       nano_value = ''
     else:
       second_value = time_value[:point_position]
-      nano_value = time_value[point_position + 1:]
+      nano_value = time_value[point_position + 1 :]
     if 't' in second_value:
       raise ValueError(
-          'time data \'{0}\' does not match format \'%Y-%m-%dT%H:%M:%S\', '
-          'lowercase \'t\' is not accepted'.format(second_value))
-    date_object = datetime.datetime.strptime(second_value, _TIMESTAMPFOMAT)
+          "time data '{0}' does not match format '%Y-%m-%dT%H:%M:%S', "
+          "lowercase 't' is not accepted".format(second_value)
+      )
+    date_object = datetime.datetime.strptime(second_value, _TIMESTAMPFORMAT)
     td = date_object - datetime.datetime(1970, 1, 1)
     seconds = td.seconds + td.days * _SECONDS_PER_DAY
     if len(nano_value) > 9:
       raise ValueError(
           'Failed to parse Timestamp: nanos {0} more than '
-          '9 fractional digits.'.format(nano_value))
+          '9 fractional digits.'.format(nano_value)
+      )
     if nano_value:
       nanos = round(float('0.' + nano_value) * 1e9)
     else:
@@ -156,18 +160,20 @@ class Timestamp(object):
     # Parse timezone offsets.
     if value[timezone_offset] == 'Z':
       if len(value) != timezone_offset + 1:
-        raise ValueError('Failed to parse timestamp: invalid trailing'
-                         ' data {0}.'.format(value))
+        raise ValueError(
+            'Failed to parse timestamp: invalid trailing data {0}.'.format(
+                value
+            )
+        )
     else:
       timezone = value[timezone_offset:]
       pos = timezone.find(':')
       if pos == -1:
-        raise ValueError(
-            'Invalid timezone offset value: {0}.'.format(timezone))
+        raise ValueError('Invalid timezone offset value: {0}.'.format(timezone))
       if timezone[0] == '+':
-        seconds -= (int(timezone[1:pos])*60+int(timezone[pos+1:]))*60
+        seconds -= (int(timezone[1:pos]) * 60 + int(timezone[pos + 1 :])) * 60
       else:
-        seconds += (int(timezone[1:pos])*60+int(timezone[pos+1:]))*60
+        seconds += (int(timezone[1:pos]) * 60 + int(timezone[pos + 1 :])) * 60
     # Set seconds and nanos
     _CheckTimestampValid(seconds, nanos)
     self.seconds = int(seconds)
@@ -175,7 +181,7 @@ class Timestamp(object):
 
   def GetCurrentTime(self):
     """Get the current UTC into Timestamp."""
-    self.FromDatetime(datetime.datetime.utcnow())
+    self.FromDatetime(datetime.datetime.now(tz=datetime.timezone.utc))
 
   def ToNanoseconds(self):
     """Converts Timestamp to nanoseconds since epoch."""
@@ -185,14 +191,16 @@ class Timestamp(object):
   def ToMicroseconds(self):
     """Converts Timestamp to microseconds since epoch."""
     _CheckTimestampValid(self.seconds, self.nanos)
-    return (self.seconds * _MICROS_PER_SECOND +
-            self.nanos // _NANOS_PER_MICROSECOND)
+    return (
+        self.seconds * _MICROS_PER_SECOND + self.nanos // _NANOS_PER_MICROSECOND
+    )
 
   def ToMilliseconds(self):
     """Converts Timestamp to milliseconds since epoch."""
     _CheckTimestampValid(self.seconds, self.nanos)
-    return (self.seconds * _MILLIS_PER_SECOND +
-            self.nanos // _NANOS_PER_MILLISECOND)
+    return (
+        self.seconds * _MILLIS_PER_SECOND + self.nanos // _NANOS_PER_MILLISECOND
+    )
 
   def ToSeconds(self):
     """Converts Timestamp to seconds since epoch."""
@@ -312,7 +320,8 @@ def _CheckTimestampValid(seconds, nanos):
   if nanos < 0 or nanos >= _NANOS_PER_SECOND:
     raise ValueError(
         'Timestamp is not valid: Nanos {} must be in a range '
-        '[0, 999999].'.format(nanos))
+        '[0, 999999].'.format(nanos)
+    )
 
 
 class Duration(object):
@@ -332,7 +341,7 @@ class Duration(object):
     _CheckDurationValid(self.seconds, self.nanos)
     if self.seconds < 0 or self.nanos < 0:
       result = '-'
-      seconds = - self.seconds + int((0 - self.nanos) // 1e9)
+      seconds = -self.seconds + int((0 - self.nanos) // 1e9)
       nanos = (0 - self.nanos) % 1e9
     else:
       result = ''
@@ -357,8 +366,8 @@ class Duration(object):
 
     Args:
       value: A string to be converted. The string must end with 's'. Any
-          fractional digits (or none) are accepted as long as they fit into
-          precision. For example: "1s", "1.01s", "1.0000001s", "-3.100s
+        fractional digits (or none) are accepted as long as they fit into
+        precision. For example: "1s", "1.01s", "1.0000001s", "-3.100s
 
     Raises:
       ValueError: On parsing problems.
@@ -366,8 +375,7 @@ class Duration(object):
     if not isinstance(value, str):
       raise ValueError('Duration JSON value not a string: {!r}'.format(value))
     if len(value) < 1 or value[-1] != 's':
-      raise ValueError(
-          'Duration must end with letter "s": {0}.'.format(value))
+      raise ValueError('Duration must end with letter "s": {0}.'.format(value))
     try:
       pos = value.find('.')
       if pos == -1:
@@ -376,15 +384,14 @@ class Duration(object):
       else:
         seconds = int(value[:pos])
         if value[0] == '-':
-          nanos = int(round(float('-0{0}'.format(value[pos: -1])) *1e9))
+          nanos = int(round(float('-0{0}'.format(value[pos:-1])) * 1e9))
         else:
-          nanos = int(round(float('0{0}'.format(value[pos: -1])) *1e9))
+          nanos = int(round(float('0{0}'.format(value[pos:-1])) * 1e9))
       _CheckDurationValid(seconds, nanos)
       self.seconds = seconds
       self.nanos = nanos
     except ValueError as e:
-      raise ValueError(
-          'Couldn\'t parse duration: {0} : {1}.'.format(value, e))
+      raise ValueError("Couldn't parse duration: {0} : {1}.".format(value, e))
 
   def ToNanoseconds(self):
     """Converts a Duration to nanoseconds."""
@@ -406,20 +413,23 @@ class Duration(object):
 
   def FromNanoseconds(self, nanos):
     """Converts nanoseconds to Duration."""
-    self._NormalizeDuration(nanos // _NANOS_PER_SECOND,
-                            nanos % _NANOS_PER_SECOND)
+    self._NormalizeDuration(
+        nanos // _NANOS_PER_SECOND, nanos % _NANOS_PER_SECOND
+    )
 
   def FromMicroseconds(self, micros):
     """Converts microseconds to Duration."""
     self._NormalizeDuration(
         micros // _MICROS_PER_SECOND,
-        (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND)
+        (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND,
+    )
 
   def FromMilliseconds(self, millis):
     """Converts milliseconds to Duration."""
     self._NormalizeDuration(
         millis // _MILLIS_PER_SECOND,
-        (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND)
+        (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND,
+    )
 
   def FromSeconds(self, seconds):
     """Converts seconds to Duration."""
@@ -429,8 +439,9 @@ class Duration(object):
   def ToTimedelta(self) -> datetime.timedelta:
     """Converts Duration to timedelta."""
     return datetime.timedelta(
-        seconds=self.seconds, microseconds=_RoundTowardZero(
-            self.nanos, _NANOS_PER_MICROSECOND))
+        seconds=self.seconds,
+        microseconds=_RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND),
+    )
 
   def FromTimedelta(self, td):
     """Converts timedelta to Duration."""
@@ -464,22 +475,26 @@ class Duration(object):
 
   __radd__ = __add__
 
-  def __rsub__(self, dt) -> Union[datetime.datetime, datetime.timedelta]:
-    return dt - self.ToTimedelta()
+  def __sub__(self, value) -> datetime.timedelta:
+    return self.ToTimedelta() - value
+
+  def __rsub__(self, value) -> Union[datetime.datetime, datetime.timedelta]:
+    return value - self.ToTimedelta()
 
 
 def _CheckDurationValid(seconds, nanos):
   if seconds < -_DURATION_SECONDS_MAX or seconds > _DURATION_SECONDS_MAX:
     raise ValueError(
         'Duration is not valid: Seconds {0} must be in range '
-        '[-315576000000, 315576000000].'.format(seconds))
+        '[-315576000000, 315576000000].'.format(seconds)
+    )
   if nanos <= -_NANOS_PER_SECOND or nanos >= _NANOS_PER_SECOND:
     raise ValueError(
         'Duration is not valid: Nanos {0} must be in range '
-        '[-999999999, 999999999].'.format(nanos))
+        '[-999999999, 999999999].'.format(nanos)
+    )
   if (nanos < 0 and seconds > 0) or (nanos > 0 and seconds < 0):
-    raise ValueError(
-        'Duration is not valid: Sign mismatch.')
+    raise ValueError('Duration is not valid: Sign mismatch.')
 
 
 def _RoundTowardZero(value, divider):
@@ -601,6 +616,7 @@ class Struct(object):
     for key, value in dictionary.items():
       _SetStructValue(self.fields[key], value)
 
+
 collections.abc.MutableMapping.register(Struct)
 
 
@@ -663,6 +679,7 @@ class ListValue(object):
     list_value.Clear()
     return list_value
 
+
 collections.abc.MutableSequence.register(ListValue)
 
 

google/protobuf/json_format.py

@@ -26,6 +26,7 @@ import json
 import math
 from operator import methodcaller
 import re
+import warnings
 
 from google.protobuf import descriptor
 from google.protobuf import message_factory
@@ -72,6 +73,7 @@ class ParseError(Error):
 
 class EnumStringValueParseError(ParseError):
   """Thrown if unknown string enum value is encountered.
+
   This exception is suppressed if ignore_unknown_fields is set.
   """
 
@@ -91,10 +93,10 @@ def MessageToJson(
 
   Args:
     message: The protocol buffers message instance to serialize.
-    always_print_fields_with_no_presence: If True, fields without
-      presence (implicit presence scalars, repeated fields, and map fields) will
-      always be serialized. Any field that supports presence is not affected by
-      this option (including singular message fields and oneof fields).
+    always_print_fields_with_no_presence: If True, fields without presence
+      (implicit presence scalars, repeated fields, and map fields) will always
+      be serialized. Any field that supports presence is not affected by this
+      option (including singular message fields and oneof fields).
     preserving_proto_field_name: If True, use the original proto field names as
       defined in the .proto file. If False, convert the field names to
       lowerCamelCase.
@@ -105,7 +107,8 @@ def MessageToJson(
     use_integers_for_enums: If true, print integers instead of enum names.
     descriptor_pool: A Descriptor Pool for resolving types. If None use the
       default.
-    float_precision: If set, use this to specify float field valid digits.
+    float_precision: Deprecated. If set, use this to specify float field valid
+      digits.
     ensure_ascii: If True, strings with non-ASCII characters are escaped. If
       False, Unicode strings are returned unchanged.
 
@@ -117,7 +120,7 @@ def MessageToJson(
       use_integers_for_enums,
       descriptor_pool,
       float_precision,
-      always_print_fields_with_no_presence
+      always_print_fields_with_no_presence,
   )
   return printer.ToJsonString(message, indent, sort_keys, ensure_ascii)
 
@@ -136,17 +139,18 @@ def MessageToDict(
 
   Args:
     message: The protocol buffers message instance to serialize.
-    always_print_fields_with_no_presence: If True, fields without
-      presence (implicit presence scalars, repeated fields, and map fields) will
-      always be serialized. Any field that supports presence is not affected by
-      this option (including singular message fields and oneof fields).
+    always_print_fields_with_no_presence: If True, fields without presence
+      (implicit presence scalars, repeated fields, and map fields) will always
+      be serialized. Any field that supports presence is not affected by this
+      option (including singular message fields and oneof fields).
     preserving_proto_field_name: If True, use the original proto field names as
       defined in the .proto file. If False, convert the field names to
       lowerCamelCase.
     use_integers_for_enums: If true, print integers instead of enum names.
     descriptor_pool: A Descriptor Pool for resolving types. If None use the
       default.
-    float_precision: If set, use this to specify float field valid digits.
+    float_precision: Deprecated. If set, use this to specify float field valid
+      digits.
 
   Returns:
     A dict representation of the protocol buffer message.
@@ -188,6 +192,11 @@ class _Printer(object):
     self.use_integers_for_enums = use_integers_for_enums
     self.descriptor_pool = descriptor_pool
     if float_precision:
+      warnings.warn(
+          'float_precision option is deprecated for json_format. '
+          'This will turn into error in 7.34.0, please remove it '
+          'before that.'
+      )
       self.float_format = '.{}g'.format(float_precision)
     else:
       self.float_format = None
@@ -215,10 +224,13 @@ class _Printer(object):
 
     try:
       for field, value in fields:
-        if self.preserving_proto_field_name:
+        if field.is_extension:
+          name = '[%s]' % field.full_name
+        elif self.preserving_proto_field_name:
           name = field.name
         else:
           name = field.json_name
+
         if _IsMapEntry(field):
           # Convert a map field.
           v_field = field.message_type.fields_by_name['value']
@@ -233,12 +245,9 @@ class _Printer(object):
               recorded_key = str(key)
             js_map[recorded_key] = self._FieldToJsonObject(v_field, value[key])
           js[name] = js_map
-        elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+        elif field.is_repeated:
           # Convert a repeated field.
           js[name] = [self._FieldToJsonObject(field, k) for k in value]
-        elif field.is_extension:
-          name = '[%s]' % field.full_name
-          js[name] = self._FieldToJsonObject(field, value)
         else:
           js[name] = self._FieldToJsonObject(field, value)
 
@@ -251,10 +260,7 @@ class _Printer(object):
 
           # always_print_fields_with_no_presence doesn't apply to
           # any field which supports presence.
-          if (
-              self.always_print_fields_with_no_presence
-              and field.has_presence
-          ):
+          if self.always_print_fields_with_no_presence and field.has_presence:
             continue
 
           if self.preserving_proto_field_name:
@@ -266,7 +272,7 @@ class _Printer(object):
             continue
           if _IsMapEntry(field):
             js[name] = {}
-          elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+          elif field.is_repeated:
             js[name] = []
           else:
             js[name] = self._FieldToJsonObject(field, field.default_value)
@@ -316,11 +322,10 @@ class _Printer(object):
           return _INFINITY
       if math.isnan(value):
         return _NAN
-      if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_FLOAT:
-        if self.float_format:
-          return float(format(value, self.float_format))
-        else:
-          return type_checkers.ToShortestFloat(value)
+      if self.float_format:
+        return float(format(value, self.float_format))
+      elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_FLOAT:
+        return type_checkers.ToShortestFloat(value)
 
     return value
 
@@ -497,6 +502,7 @@ def ParseDict(
 
 
 _INT_OR_FLOAT = (int, float)
+_LIST_LIKE = (list, tuple)
 
 
 class _Parser(object):
@@ -556,6 +562,25 @@ class _Parser(object):
     fields_by_json_name = dict(
         (f.json_name, f) for f in message_descriptor.fields
     )
+
+    def _ClearFieldOrExtension(message, field):
+      if field.is_extension:
+        message.ClearExtension(field)
+      else:
+        message.ClearField(field.name)
+
+    def _GetFieldOrExtension(message, field):
+      if field.is_extension:
+        return message.Extensions[field]
+      else:
+        return getattr(message, field.name)
+
+    def _SetFieldOrExtension(message, field, value):
+      if field.is_extension:
+        message.Extensions[field] = value
+      else:
+        setattr(message, field.name, value)
+
     for name in js:
       try:
         field = fields_by_json_name.get(name, None)
@@ -619,26 +644,26 @@ class _Parser(object):
               field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE
               and field.message_type.full_name == 'google.protobuf.Value'
           ):
-            sub_message = getattr(message, field.name)
+            sub_message = _GetFieldOrExtension(message, field)
             sub_message.null_value = 0
           elif (
               field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM
               and field.enum_type.full_name == 'google.protobuf.NullValue'
           ):
-            setattr(message, field.name, 0)
+            _SetFieldOrExtension(message, field, 0)
           else:
-            message.ClearField(field.name)
+            _ClearFieldOrExtension(message, field)
           continue
 
         # Parse field value.
         if _IsMapEntry(field):
-          message.ClearField(field.name)
+          _ClearFieldOrExtension(message, field)
           self._ConvertMapFieldValue(
               value, message, field, '{0}.{1}'.format(path, name)
           )
-        elif field.label == descriptor.FieldDescriptor.LABEL_REPEATED:
-          message.ClearField(field.name)
-          if not isinstance(value, list):
+        elif field.is_repeated:
+          _ClearFieldOrExtension(message, field)
+          if not isinstance(value, _LIST_LIKE):
             raise ParseError(
                 'repeated field {0} must be in [] which is {1} at {2}'.format(
                     name, value, path
@@ -647,7 +672,7 @@ class _Parser(object):
           if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
             # Repeated message field.
             for index, item in enumerate(value):
-              sub_message = getattr(message, field.name).add()
+              sub_message = _GetFieldOrExtension(message, field).add()
               # None is a null_value in Value.
               if (
                   item is None
@@ -674,19 +699,16 @@ class _Parser(object):
                     )
                 )
               self._ConvertAndAppendScalar(
-                message, field, item, '{0}.{1}[{2}]'.format(path, name, index))
+                  message, field, item, '{0}.{1}[{2}]'.format(path, name, index)
+              )
         elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
-          if field.is_extension:
-            sub_message = message.Extensions[field]
-          else:
-            sub_message = getattr(message, field.name)
+          sub_message = _GetFieldOrExtension(message, field)
           sub_message.SetInParent()
           self.ConvertMessage(value, sub_message, '{0}.{1}'.format(path, name))
         else:
-          if field.is_extension:
-            self._ConvertAndSetScalarExtension(message, field, value, '{0}.{1}'.format(path, name))
-          else:
-            self._ConvertAndSetScalar(message, field, value, '{0}.{1}'.format(path, name))
+          self._ConvertAndSetScalar(
+              message, field, value, '{0}.{1}'.format(path, name)
+          )
       except ParseError as e:
         if field and field.containing_oneof is None:
           raise ParseError(
@@ -733,8 +755,10 @@ class _Parser(object):
       )(self)
     else:
       del value['@type']
-      self._ConvertFieldValuePair(value, sub_message, path)
-      value['@type'] = type_url
+      try:
+        self._ConvertFieldValuePair(value, sub_message, path)
+      finally:
+        value['@type'] = type_url
     # Sets Any message
     message.value = sub_message.SerializeToString()
     message.type_url = type_url
@@ -752,8 +776,8 @@ class _Parser(object):
     """Convert a JSON representation into Value message."""
     if isinstance(value, dict):
       self._ConvertStructMessage(value, message.struct_value, path)
-    elif isinstance(value, list):
-      self._ConvertListValueMessage(value, message.list_value, path)
+    elif isinstance(value, _LIST_LIKE):
+      self._ConvertListOrTupleValueMessage(value, message.list_value, path)
     elif value is None:
       message.null_value = 0
     elif isinstance(value, bool):
@@ -769,9 +793,9 @@ class _Parser(object):
           )
       )
 
-  def _ConvertListValueMessage(self, value, message, path):
+  def _ConvertListOrTupleValueMessage(self, value, message, path):
     """Convert a JSON representation into ListValue message."""
-    if not isinstance(value, list):
+    if not isinstance(value, _LIST_LIKE):
       raise ParseError(
           'ListValue must be in [] which is {0} at {1}'.format(value, path)
       )
@@ -799,7 +823,9 @@ class _Parser(object):
   def _ConvertWrapperMessage(self, value, message, path):
     """Convert a JSON representation into Wrapper message."""
     field = message.DESCRIPTOR.fields_by_name['value']
-    self._ConvertAndSetScalar(message, field, value, path='{0}.value'.format(path))
+    self._ConvertAndSetScalar(
+        message, field, value, path='{0}.value'.format(path)
+    )
 
   def _ConvertMapFieldValue(self, value, message, field, path):
     """Convert map field value for a message map field.
@@ -837,24 +863,17 @@ class _Parser(object):
             field,
             key_value,
             value[key],
-            path='{0}[{1}]'.format(path, key_value))
-
-  def _ConvertAndSetScalarExtension(self, message, extension_field, js_value, path):
-    """Convert scalar from js_value and assign it to message.Extensions[extension_field]."""
-    try:
-      message.Extensions[extension_field] = _ConvertScalarFieldValue(
-          js_value, extension_field, path)
-    except EnumStringValueParseError:
-      if not self.ignore_unknown_fields:
-        raise
+            path='{0}[{1}]'.format(path, key_value),
+        )
 
   def _ConvertAndSetScalar(self, message, field, js_value, path):
     """Convert scalar from js_value and assign it to message.field."""
     try:
-      setattr(
-          message,
-          field.name,
-          _ConvertScalarFieldValue(js_value, field, path))
+      value = _ConvertScalarFieldValue(js_value, field, path)
+      if field.is_extension:
+        message.Extensions[field] = value
+      else:
+        setattr(message, field.name, value)
     except EnumStringValueParseError:
       if not self.ignore_unknown_fields:
         raise
@@ -862,17 +881,27 @@ class _Parser(object):
   def _ConvertAndAppendScalar(self, message, repeated_field, js_value, path):
     """Convert scalar from js_value and append it to message.repeated_field."""
     try:
-      getattr(message, repeated_field.name).append(
-          _ConvertScalarFieldValue(js_value, repeated_field, path))
+      if repeated_field.is_extension:
+        repeated = message.Extensions[repeated_field]
+      else:
+        repeated = getattr(message, repeated_field.name)
+      value = _ConvertScalarFieldValue(js_value, repeated_field, path)
+      repeated.append(value)
     except EnumStringValueParseError:
       if not self.ignore_unknown_fields:
         raise
 
-  def _ConvertAndSetScalarToMapKey(self, message, map_field, converted_key, js_value, path):
+  def _ConvertAndSetScalarToMapKey(
+      self, message, map_field, converted_key, js_value, path
+  ):
     """Convert scalar from 'js_value' and add it to message.map_field[converted_key]."""
     try:
-      getattr(message, map_field.name)[converted_key] = _ConvertScalarFieldValue(
-          js_value, map_field.message_type.fields_by_name['value'], path,
+      getattr(message, map_field.name)[converted_key] = (
+          _ConvertScalarFieldValue(
+              js_value,
+              map_field.message_type.fields_by_name['value'],
+              path,
+          )
       )
     except EnumStringValueParseError:
       if not self.ignore_unknown_fields:
@@ -971,7 +1000,20 @@ def _ConvertInteger(value):
         'Bool value {0} is not acceptable for integer field'.format(value)
     )
 
-  return int(value)
+  try:
+    return int(value)
+  except ValueError as e:
+    # Attempt to parse as an integer-valued float.
+    try:
+      f = float(value)
+    except ValueError:
+      # Raise the original exception for the int parse.
+      raise e  # pylint: disable=raise-missing-from
+    if not f.is_integer():
+      raise ParseError(
+          'Couldn\'t parse non-integer string: "{0}"'.format(value)
+      ) from e
+    return int(f)
 
 
 def _ConvertFloat(value, field):
@@ -1052,7 +1094,7 @@ _WKTJSONMETHODS = {
     ],
     'google.protobuf.ListValue': [
         '_ListValueMessageToJsonObject',
-        '_ConvertListValueMessage',
+        '_ConvertListOrTupleValueMessage',
     ],
     'google.protobuf.Struct': [
         '_StructMessageToJsonObject',