third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/python/google/protobuf/internal/well_known_types.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.
@@ skipping 35 matching lines @@
 
 from google.protobuf.descriptor import FieldDescriptor
 
 _TIMESTAMPFOMAT = '%Y-%m-%dT%H:%M:%S'
 _NANOS_PER_SECOND = 1000000000
 _NANOS_PER_MILLISECOND = 1000000
 _NANOS_PER_MICROSECOND = 1000
 _MILLIS_PER_SECOND = 1000
 _MICROS_PER_SECOND = 1000000
 _SECONDS_PER_DAY = 24 * 3600
+_DURATION_SECONDS_MAX = 315576000000
 
 
 class Error(Exception):
   """Top-level module error."""
 
 
 class ParseError(Error):
   """Thrown in case of parsing error."""
 
 
@@ skipping 174 matching lines @@
 
   def ToJsonString(self):
     """Converts Duration to string format.
 
     Returns:
       A string converted from self. The string format will contains
       3, 6, or 9 fractional digits depending on the precision required to
       represent the exact Duration value. For example: "1s", "1.010s",
       "1.000000100s", "-3.100s"
     """
+    _CheckDurationValid(self.seconds, self.nanos)
     if self.seconds < 0 or self.nanos < 0:
       result = '-'
       seconds = - self.seconds + int((0 - self.nanos) // 1e9)
       nanos = (0 - self.nanos) % 1e9
     else:
       result = ''
       seconds = self.seconds + int(self.nanos // 1e9)
       nanos = self.nanos % 1e9
     result += '%d' % seconds
     if (nanos % 1e9) == 0:
@@ skipping 19 matching lines @@
 
     Raises:
       ParseError: On parsing problems.
     """
     if len(value) < 1 or value[-1] != 's':
       raise ParseError(
           'Duration must end with letter "s": {0}.'.format(value))
     try:
       pos = value.find('.')
       if pos == -1:
-        self.seconds = int(value[:-1])
-        self.nanos = 0
+        seconds = int(value[:-1])
+        nanos = 0
       else:
-        self.seconds = int(value[:pos])
+        seconds = int(value[:pos])
         if value[0] == '-':
-          self.nanos = int(round(float('-0{0}'.format(value[pos: -1])) *1e9))
+          nanos = int(round(float('-0{0}'.format(value[pos: -1])) *1e9))
         else:
-          self.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:
       raise ParseError(
           'Couldn\'t parse duration: {0}.'.format(value))
 
   def ToNanoseconds(self):
     """Converts a Duration to nanoseconds."""
     return self.seconds * _NANOS_PER_SECOND + self.nanos
 
   def ToMicroseconds(self):
     """Converts a Duration to microseconds."""
@@ skipping 45 matching lines @@
   def _NormalizeDuration(self, seconds, nanos):
     """Set Duration by seconds and nonas."""
     # Force nanos to be negative if the duration is negative.
     if seconds < 0 and nanos > 0:
       seconds += 1
       nanos -= _NANOS_PER_SECOND
     self.seconds = seconds
     self.nanos = nanos
 
 
+def _CheckDurationValid(seconds, nanos):
+  if seconds < -_DURATION_SECONDS_MAX or seconds > _DURATION_SECONDS_MAX:
+    raise Error(
+        'Duration is not valid: Seconds {0} must be in range '
+        '[-315576000000, 315576000000].'.format(seconds))
+  if nanos <= -_NANOS_PER_SECOND or nanos >= _NANOS_PER_SECOND:
+    raise Error(
+        'Duration is not valid: Nanos {0} must be in range '
+        '[-999999999, 999999999].'.format(nanos))
+
+
 def _RoundTowardZero(value, divider):
   """Truncates the remainder part after division."""
   # For some languanges, the sign of the remainder is implementation
   # dependent if any of the operands is negative. Here we enforce
   # "rounded toward zero" semantics. For example, for (-5) / 2 an
   # implementation may give -3 as the result with the remainder being
   # 1. This function ensures we always return -2 (closer to zero).
   result = value // divider
   remainder = value % divider
   if result < 0 and remainder > 0:
     return result + 1
   else:
     return result
 
 
 class FieldMask(object):
   """Class for FieldMask message type."""
 
   def ToJsonString(self):
     """Converts FieldMask to string according to proto3 JSON spec."""
-    return ','.join(self.paths)
+    camelcase_paths = []
+    for path in self.paths:
+      camelcase_paths.append(_SnakeCaseToCamelCase(path))
+    return ','.join(camelcase_paths)
 
   def FromJsonString(self, value):
     """Converts string to FieldMask according to proto3 JSON spec."""
     self.Clear()
     for path in value.split(','):
-      self.paths.append(path)
+      self.paths.append(_CamelCaseToSnakeCase(path))
 
   def IsValidForDescriptor(self, message_descriptor):
     """Checks whether the FieldMask is valid for Message Descriptor."""
     for path in self.paths:
       if not _IsValidPath(message_descriptor, path):
         return False
     return True
 
   def AllFieldsFromDescriptor(self, message_descriptor):
     """Gets all direct fields of Message Descriptor to FieldMask."""
@@ skipping 66 matching lines @@
 
 def _CheckFieldMaskMessage(message):
   """Raises ValueError if message is not a FieldMask."""
   message_descriptor = message.DESCRIPTOR
   if (message_descriptor.name != 'FieldMask' or
       message_descriptor.file.name != 'google/protobuf/field_mask.proto'):
     raise ValueError('Message {0} is not a FieldMask.'.format(
         message_descriptor.full_name))
 
 
+def _SnakeCaseToCamelCase(path_name):
+  """Converts a path name from snake_case to camelCase."""
+  result = []
+  after_underscore = False
+  for c in path_name:
+    if c.isupper():
+      raise Error('Fail to print FieldMask to Json string: Path name '
+                  '{0} must not contain uppercase letters.'.format(path_name))
+    if after_underscore:
+      if c.islower():
+        result.append(c.upper())
+        after_underscore = False
+      else:
+        raise Error('Fail to print FieldMask to Json string: The '
+                    'character after a "_" must be a lowercase letter '
+                    'in path name {0}.'.format(path_name))
+    elif c == '_':
+      after_underscore = True
+    else:
+      result += c
+
+  if after_underscore:
+    raise Error('Fail to print FieldMask to Json string: Trailing "_" '
+                'in path name {0}.'.format(path_name))
+  return ''.join(result)
+
+
+def _CamelCaseToSnakeCase(path_name):
+  """Converts a field name from camelCase to snake_case."""
+  result = []
+  for c in path_name:
+    if c == '_':
+      raise ParseError('Fail to parse FieldMask: Path name '
+                       '{0} must not contain "_"s.'.format(path_name))
+    if c.isupper():
+      result += '_'
+      result += c.lower()
+    else:
+      result += c
+  return ''.join(result)
+
+
 class _FieldMaskTree(object):
   """Represents a FieldMask in a tree structure.
 
   For example, given a FieldMask "foo.bar,foo.baz,bar.baz",
   the FieldMaskTree will be:
       [_root] -+- foo -+- bar
             |       |
             |       +- baz
             |
             +- bar --- baz
@@ skipping 230 matching lines @@
 
 
 WKTBASES = {
     'google.protobuf.Any': Any,
     'google.protobuf.Duration': Duration,
     'google.protobuf.FieldMask': FieldMask,
     'google.protobuf.ListValue': ListValue,
     'google.protobuf.Struct': Struct,
     'google.protobuf.Timestamp': Timestamp,
 }