protobuf 6.30.0__cp39-cp39-win_amd64.whl → 6.33.2__cp39-cp39-win_amd64.whl

google/protobuf/internal/python_message.py

@@ -256,7 +256,8 @@ def _IsMessageSetExtension(field):
           field.containing_type.has_options and
           field.containing_type.GetOptions().message_set_wire_format and
           field.type == _FieldDescriptor.TYPE_MESSAGE and
-          field.label == _FieldDescriptor.LABEL_OPTIONAL)
+          not field.is_required and
+          not field.is_repeated)
 
 
 def _IsMapField(field):
@@ -269,7 +270,6 @@ def _IsMessageMapField(field):
   return value_type.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE
 
 def _AttachFieldHelpers(cls, field_descriptor):
-  is_repeated = field_descriptor.label == _FieldDescriptor.LABEL_REPEATED
   field_descriptor._default_constructor = _DefaultValueConstructorForField(
       field_descriptor
   )
@@ -282,7 +282,9 @@ def _AttachFieldHelpers(cls, field_descriptor):
       type_checkers.FIELD_TYPE_TO_WIRE_TYPE[field_descriptor.type], False
   )
 
-  if is_repeated and wire_format.IsTypePackable(field_descriptor.type):
+  if field_descriptor.is_repeated and wire_format.IsTypePackable(
+      field_descriptor.type
+  ):
     # To support wire compatibility of adding packed = true, add a decoder for
     # packed values regardless of the field's options.
     AddFieldByTag(wire_format.WIRETYPE_LENGTH_DELIMITED, True)
@@ -291,7 +293,7 @@ def _AttachFieldHelpers(cls, field_descriptor):
 def _MaybeAddEncoder(cls, field_descriptor):
   if hasattr(field_descriptor, '_encoder'):
     return
-  is_repeated = (field_descriptor.label == _FieldDescriptor.LABEL_REPEATED)
+  is_repeated = field_descriptor.is_repeated
   is_map_entry = _IsMapField(field_descriptor)
   is_packed = field_descriptor.is_packed
 
@@ -316,7 +318,7 @@ def _MaybeAddDecoder(cls, field_descriptor):
   if hasattr(field_descriptor, '_decoders'):
     return
 
-  is_repeated = field_descriptor.label == _FieldDescriptor.LABEL_REPEATED
+  is_repeated = field_descriptor.is_repeated
   is_map_entry = _IsMapField(field_descriptor)
   helper_decoders = {}
 
@@ -387,7 +389,7 @@ def _AddEnumValues(descriptor, cls):
 
 
 def _GetInitializeDefaultForMap(field):
-  if field.label != _FieldDescriptor.LABEL_REPEATED:
+  if not field.is_repeated:
     raise ValueError('map_entry set on non-repeated field %s' % (
         field.name))
   fields_by_name = field.message_type.fields_by_name
@@ -425,7 +427,7 @@ def _DefaultValueConstructorForField(field):
   if _IsMapField(field):
     return _GetInitializeDefaultForMap(field)
 
-  if field.label == _FieldDescriptor.LABEL_REPEATED:
+  if field.is_repeated:
     if field.has_default_value and field.default_value != []:
       raise ValueError('Repeated field default value not empty list: %s' % (
           field.default_value))
@@ -496,6 +498,35 @@ def _AddInitMethod(message_descriptor, cls):
     return value
 
   def init(self, **kwargs):
+
+    def init_wkt_or_merge(field, msg, value):
+      if isinstance(value, message_mod.Message):
+        msg.MergeFrom(value)
+      elif (
+          isinstance(value, dict)
+          and field.message_type.full_name == _StructFullTypeName
+      ):
+        msg.Clear()
+        if len(value) == 1 and 'fields' in value:
+          try:
+            msg.update(value)
+          except:
+            msg.Clear()
+            msg.__init__(**value)
+        else:
+          msg.update(value)
+      elif hasattr(msg, '_internal_assign'):
+        msg._internal_assign(value)
+      else:
+        raise TypeError(
+            'Message field {0}.{1} must be initialized with a '
+            'dict or instance of same class, got {2}.'.format(
+                message_descriptor.name,
+                field.name,
+                type(value).__name__,
+            )
+        )
+
     self._cached_byte_size = 0
     self._cached_byte_size_dirty = len(kwargs) > 0
     self._fields = {}
@@ -517,7 +548,7 @@ def _AddInitMethod(message_descriptor, cls):
       if field_value is None:
         # field=None is the same as no field at all.
         continue
-      if field.label == _FieldDescriptor.LABEL_REPEATED:
+      if field.is_repeated:
         field_copy = field._default_constructor(self)
         if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:  # Composite
           if _IsMapField(field):
@@ -532,10 +563,13 @@ def _AddInitMethod(message_descriptor, cls):
               field_copy.update(field_value)
           else:
             for val in field_value:
-              if isinstance(val, dict):
+              if isinstance(val, dict) and (
+                  field.message_type.full_name != _StructFullTypeName
+              ):
                 field_copy.add(**val)
               else:
-                field_copy.add().MergeFrom(val)
+                new_msg = field_copy.add()
+                init_wkt_or_merge(field, new_msg, val)
         else:  # Scalar
           if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:
             field_value = [_GetIntegerEnumValue(field.enum_type, val)
@@ -544,38 +578,14 @@ def _AddInitMethod(message_descriptor, cls):
         self._fields[field] = field_copy
       elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
         field_copy = field._default_constructor(self)
-        new_val = None
-        if isinstance(field_value, message_mod.Message):
-          new_val = field_value
-        elif isinstance(field_value, dict):
-          if field.message_type.full_name == _StructFullTypeName:
-            field_copy.Clear()
-            if len(field_value) == 1 and 'fields' in field_value:
-              try:
-                field_copy.update(field_value)
-              except:
-                # Fall back to init normal message field
-                field_copy.Clear()
-                new_val = field.message_type._concrete_class(**field_value)
-            else:
-              field_copy.update(field_value)
-          else:
-            new_val = field.message_type._concrete_class(**field_value)
-        elif hasattr(field_copy, '_internal_assign'):
-          field_copy._internal_assign(field_value)
+        if isinstance(field_value, dict) and (
+            field.message_type.full_name != _StructFullTypeName
+        ):
+          new_val = field.message_type._concrete_class(**field_value)
+          field_copy.MergeFrom(new_val)
         else:
-          raise TypeError(
-              'Message field {0}.{1} must be initialized with a '
-              'dict or instance of same class, got {2}.'.format(
-                  message_descriptor.name,
-                  field_name,
-                  type(field_value).__name__,
-              )
-          )
-
-        if new_val != None:
           try:
-            field_copy.MergeFrom(new_val)
+            init_wkt_or_merge(field, field_copy, field_value)
           except TypeError:
             _ReraiseTypeErrorWithFieldName(message_descriptor.name, field_name)
         self._fields[field] = field_copy
@@ -636,7 +646,7 @@ def _AddPropertiesForField(field, cls):
   constant_name = field.name.upper() + '_FIELD_NUMBER'
   setattr(cls, constant_name, field.number)
 
-  if field.label == _FieldDescriptor.LABEL_REPEATED:
+  if field.is_repeated:
     _AddPropertiesForRepeatedField(field, cls)
   elif field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
     _AddPropertiesForNonRepeatedCompositeField(field, cls)
@@ -827,6 +837,13 @@ def _AddPropertiesForExtensions(descriptor, cls):
     pool = descriptor.file.pool
 
 def _AddStaticMethods(cls):
+
+  def RegisterExtension(_):
+    """no-op to keep generated code <=4.23 working with new runtimes."""
+    # This was originally removed in 5.26 (cl/595989309).
+    pass
+
+  cls.RegisterExtension = staticmethod(RegisterExtension)
   def FromString(s):
     message = cls()
     message.MergeFromString(s)
@@ -838,7 +855,7 @@ def _IsPresent(item):
   """Given a (FieldDescriptor, value) tuple from _fields, return true if the
   value should be included in the list returned by ListFields()."""
 
-  if item[0].label == _FieldDescriptor.LABEL_REPEATED:
+  if item[0].is_repeated:
     return bool(item[1])
   elif item[0].cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
     return item[1]._is_present_in_parent
@@ -862,7 +879,7 @@ def _AddHasFieldMethod(message_descriptor, cls):
 
   hassable_fields = {}
   for field in message_descriptor.fields:
-    if field.label == _FieldDescriptor.LABEL_REPEATED:
+    if field.is_repeated:
       continue
     # For proto3, only submessages and fields inside a oneof have presence.
     if not field.has_presence:
@@ -950,7 +967,7 @@ def _AddHasExtensionMethod(cls):
   """Helper for _AddMessageMethods()."""
   def HasExtension(self, field_descriptor):
     extension_dict._VerifyExtensionHandle(self, field_descriptor)
-    if field_descriptor.label == _FieldDescriptor.LABEL_REPEATED:
+    if field_descriptor.is_repeated:
       raise KeyError('"%s" is repeated.' % field_descriptor.full_name)
 
     if field_descriptor.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
@@ -1200,7 +1217,7 @@ def _AddMergeFromStringMethod(message_descriptor, cls):
   fields_by_tag = cls._fields_by_tag
   message_set_decoders_by_tag = cls._message_set_decoders_by_tag
 
-  def InternalParse(self, buffer, pos, end):
+  def InternalParse(self, buffer, pos, end, current_depth=0):
     """Create a message from serialized bytes.
 
     Args:
@@ -1244,10 +1261,13 @@ def _AddMergeFromStringMethod(message_descriptor, cls):
       else:
         _MaybeAddDecoder(cls, field_des)
         field_decoder = field_des._decoders[is_packed]
-        pos = field_decoder(buffer, new_pos, end, self, field_dict)
+        pos = field_decoder(
+            buffer, new_pos, end, self, field_dict, current_depth
+        )
         if field_des.containing_oneof:
           self._UpdateOneofState(field_des)
     return pos
+
   cls._InternalParse = InternalParse
 
 
@@ -1256,7 +1276,7 @@ def _AddIsInitializedMethod(message_descriptor, cls):
   protocol message class."""
 
   required_fields = [field for field in message_descriptor.fields
-                           if field.label == _FieldDescriptor.LABEL_REQUIRED]
+                           if field.is_required]
 
   def IsInitialized(self, errors=None):
     """Checks if all required fields of a message are set.
@@ -1281,7 +1301,7 @@ def _AddIsInitializedMethod(message_descriptor, cls):
 
     for field, value in list(self._fields.items()):  # dict can change size!
       if field.cpp_type == _FieldDescriptor.CPPTYPE_MESSAGE:
-        if field.label == _FieldDescriptor.LABEL_REPEATED:
+        if field.is_repeated:
           if (field.message_type._is_map_entry):
             continue
           for element in value:
@@ -1329,7 +1349,7 @@ def _AddIsInitializedMethod(message_descriptor, cls):
           else:
             # ScalarMaps can't have any initialization errors.
             pass
-        elif field.label == _FieldDescriptor.LABEL_REPEATED:
+        elif field.is_repeated:
           for i in range(len(value)):
             element = value[i]
             prefix = '%s[%d].' % (name, i)
@@ -1354,7 +1374,6 @@ def _FullyQualifiedClassName(klass):
 
 
 def _AddMergeFromMethod(cls):
-  LABEL_REPEATED = _FieldDescriptor.LABEL_REPEATED
   CPPTYPE_MESSAGE = _FieldDescriptor.CPPTYPE_MESSAGE
 
   def MergeFrom(self, msg):
@@ -1370,7 +1389,7 @@ def _AddMergeFromMethod(cls):
     fields = self._fields
 
     for field, value in msg._fields.items():
-      if field.label == LABEL_REPEATED:
+      if field.is_repeated:
         field_value = fields.get(field)
         if field_value is None:
           # Construct a new object to represent this field.
@@ -1439,7 +1458,7 @@ def _DiscardUnknownFields(self):
         if _IsMessageMapField(field):
           for key in value:
             value[key].DiscardUnknownFields()
-      elif field.label == _FieldDescriptor.LABEL_REPEATED:
+      elif field.is_repeated:
         for sub_message in value:
           sub_message.DiscardUnknownFields()
       else:

google/protobuf/internal/testing_refleaks.py

@@ -62,11 +62,13 @@ class ReferenceLeakCheckerMixin(object):
     super(ReferenceLeakCheckerMixin, self).run(result=result)
     super(ReferenceLeakCheckerMixin, self).run(result=result)
 
-    oldrefcount = 0  # pylint: disable=unused-variable but needed for refcounts.
     local_result = LocalTestResult(result)
     num_flakes = 0
-
     refcount_deltas = []
+
+    # Observe the refcount, then create oldrefcount which actually makes the
+    # refcount 1 higher than the recorded value immediately
+    oldrefcount = self._getRefcounts()
     while len(refcount_deltas) < self.NB_RUNS:
       oldrefcount = self._getRefcounts()
       super(ReferenceLeakCheckerMixin, self).run(result=local_result)
@@ -90,6 +92,10 @@ class ReferenceLeakCheckerMixin(object):
       result.addError(self, sys.exc_info())
 
   def _getRefcounts(self):
+    if hasattr(sys, "_clear_internal_caches"):  # Since 3.13
+      sys._clear_internal_caches()  # pylint: disable=protected-access
+    else:
+      sys._clear_type_cache()  # pylint: disable=protected-access
     copyreg.dispatch_table.clear()
     copyreg.dispatch_table.update(self._saved_pickle_registry)
     # It is sometimes necessary to gc.collect() multiple times, to ensure

google/protobuf/internal/type_checkers.py

@@ -22,16 +22,20 @@ TYPE_TO_DESERIALIZE_METHOD: A dictionary with field types and deserialization
 
 __author__ = 'robinson@google.com (Will Robinson)'
 
-import struct
 import numbers
+import struct
+import warnings
 
+from google.protobuf import descriptor
 from google.protobuf.internal import decoder
 from google.protobuf.internal import encoder
 from google.protobuf.internal import wire_format
-from google.protobuf import descriptor
 
 _FieldDescriptor = descriptor.FieldDescriptor
-
+# TODO: Remove this warning count after 34.0
+# Assign bool to int/enum warnings will print 100 times at most which should
+# be enough for users to notice and do not cause timeout.
+_BoolWarningCount = 100
 
 def TruncateToFourByteFloat(original):
   return struct.unpack('<f', struct.pack('<f', original))[0]
@@ -113,12 +117,21 @@ class BoolValueChecker(object):
   """Type checker used for bool fields."""
 
   def CheckValue(self, proposed_value):
-    if not hasattr(proposed_value, '__index__') or (
-        type(proposed_value).__module__ == 'numpy' and
+    if not hasattr(proposed_value, '__index__'):
+      # Under NumPy 2.3, numpy.bool does not have an __index__ method.
+      if (type(proposed_value).__module__ == 'numpy' and
+          type(proposed_value).__name__ == 'bool'):
+        return bool(proposed_value)
+      message = ('%.1024r has type %s, but expected one of: %s' %
+                 (proposed_value, type(proposed_value), (bool, int)))
+      raise TypeError(message)
+
+    if (type(proposed_value).__module__ == 'numpy' and
         type(proposed_value).__name__ == 'ndarray'):
       message = ('%.1024r has type %s, but expected one of: %s' %
                  (proposed_value, type(proposed_value), (bool, int)))
       raise TypeError(message)
+
     return bool(proposed_value)
 
   def DefaultValue(self):
@@ -132,6 +145,21 @@ class IntValueChecker(object):
   """Checker used for integer fields.  Performs type-check and range check."""
 
   def CheckValue(self, proposed_value):
+    global _BoolWarningCount
+    if type(proposed_value) == bool and _BoolWarningCount > 0:
+      _BoolWarningCount -= 1
+      message = (
+          '%.1024r has type %s, but expected one of: %s. This warning '
+          'will turn into error in 7.34.0, please fix it before that.'
+          % (
+              proposed_value,
+              type(proposed_value),
+              (int,),
+          )
+      )
+      # TODO: Raise errors in 2026 Q1 release
+      warnings.warn(message)
+
     if not hasattr(proposed_value, '__index__') or (
         type(proposed_value).__module__ == 'numpy' and
         type(proposed_value).__name__ == 'ndarray'):
@@ -158,6 +186,20 @@ class EnumValueChecker(object):
     self._enum_type = enum_type
 
   def CheckValue(self, proposed_value):
+    global _BoolWarningCount
+    if type(proposed_value) == bool and _BoolWarningCount > 0:
+      _BoolWarningCount -= 1
+      message = (
+          '%.1024r has type %s, but expected one of: %s. This warning '
+          'will turn into error in 7.34.0, please fix it before that.'
+          % (
+              proposed_value,
+              type(proposed_value),
+              (int,),
+          )
+      )
+      # TODO: Raise errors in 2026 Q1 release
+      warnings.warn(message)
     if not isinstance(proposed_value, numbers.Integral):
       message = ('%.1024r has type %s, but expected one of: %s' %
                  (proposed_value, type(proposed_value), (int,)))

google/protobuf/internal/well_known_types.py

@@ -20,9 +20,9 @@ __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
 
@@ -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)
@@ -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))
+          "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)