Add construction support for repeated Timestamp/Duration/Struct/ListValue.

-Users can now assign list datetime/temedelta to repeated Timestamp/Duration in construction.
-Can assign list dictionary to repeated Struct.
-Can assign list of list to repeated ListValue.

#21541

PiperOrigin-RevId: 804523563

Author: anandolee

python/google/protobuf/internal/duration_test.py

@@ -67,6 +67,15 @@ def test_duration_construction(self):
     )
     self.assertEqual(expected_td, message.optional_duration.ToTimedelta())
 
+  def test_repeated_duration_construction(self):
+    td0 = datetime.timedelta(microseconds=123)
+    td1 = datetime.timedelta(microseconds=456)
+    dr = duration_pb2.Duration()
+    message = well_known_types_test_pb2.WKTMessage(repeated_td=[td0, td1, dr])
+    self.assertEqual(td0, duration.to_timedelta(message.repeated_td[0]))
+    self.assertEqual(td1, duration.to_timedelta(message.repeated_td[1]))
+    self.assertEqual(dr, message.repeated_td[2])
+
   def test_duration_sub_annotation(self):
     dt = datetime.datetime.now()
     dr = duration_pb2.Duration()

python/google/protobuf/internal/python_message.py

@@ -498,6 +498,35 @@ def _GetIntegerEnumValue(enum_type, value):
     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 = {}
@@ -534,10 +563,13 @@ def init(self, **kwargs):
               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)
@@ -546,38 +578,14 @@ def init(self, **kwargs):
         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

python/google/protobuf/internal/timestamp_test.py

@@ -66,6 +66,25 @@ def test_timstamp_construction(self):
         optional_timestamp=datetime.datetime.today()
     )
 
+  def test_repeated_timestamp_construction(self):
+    message = well_known_types_test_pb2.WKTMessage(
+        repeated_ts=[
+            datetime.datetime(2025, 1, 1),
+            datetime.datetime(1970, 1, 1),
+            timestamp_pb2.Timestamp(),
+        ]
+    )
+    self.assertEqual(len(message.repeated_ts), 3)
+    self.assertEqual(
+        datetime.datetime(2025, 1, 1),
+        timestamp.to_datetime((message.repeated_ts[0])),
+    )
+    self.assertEqual(
+        datetime.datetime(1970, 1, 1),
+        timestamp.to_datetime((message.repeated_ts[1])),
+    )
+    self.assertEqual(timestamp_pb2.Timestamp(), message.repeated_ts[2])
+
   def test_timestamp_sub_annotation(self):
     t1 = timestamp_pb2.Timestamp()
     t2 = timestamp_pb2.Timestamp()

python/google/protobuf/internal/well_known_types_test.proto

@@ -26,4 +26,9 @@ message WKTMessage {
   Duration optional_duration = 2;
   Struct optional_struct = 3;
   ListValue optional_list_value = 4;
+
+  repeated Timestamp repeated_ts = 5;
+  repeated Duration repeated_td = 6;
+  repeated Struct repeated_struct = 7;
+  repeated ListValue repeated_list = 8;
 }

python/google/protobuf/internal/well_known_types_test.py

@@ -945,6 +945,30 @@ def testSpecialStructConstruct(self):
     msg3 = well_known_types_test_pb2.WKTMessage(optional_struct=dictionary3)
     self.assertEqual(msg3.optional_struct, {'key1': 5.0})
 
+  def testRepeatedStructConstruct(self):
+    dict0 = {'key1': 6.0}
+    dict1 = {
+        'key1': 'abc',
+        'key2': {'subkey': 11.0, 'k': True},
+    }
+    value_msg = struct_pb2.Value(number_value=5.0)
+    dict2 = {'fields': {'key1': value_msg}}
+    msg = well_known_types_test_pb2.WKTMessage(
+        repeated_struct=[dict0, dict1, dict2]
+    )
+    self.assertEqual(len(msg.repeated_struct), 3)
+    self.assertEqual(msg.repeated_struct[0], dict0)
+    self.assertEqual(msg.repeated_struct[1], dict1)
+    self.assertEqual(msg.repeated_struct[2], {'key1': 5.0})
+
+  def testRepeatedListValueConstruct(self):
+    list0 = [6, 'seven', True, False]
+    list1 = [None, {'key': 1.2}]
+    msg = well_known_types_test_pb2.WKTMessage(repeated_list=[list0, list1])
+    self.assertEqual(len(msg.repeated_list), 2)
+    self.assertEqual(msg.repeated_list[0], list0)
+    self.assertEqual(msg.repeated_list[1], list1)
+
   def testMergeFrom(self):
     struct = struct_pb2.Struct()
     struct_class = struct.__class__

python/google/protobuf/pyext/message.cc

@@ -986,6 +986,53 @@ int DeleteRepeatedField(CMessage* self, const FieldDescriptor* field_descriptor,
   return 0;
 }
 
+int InitWKTOrMerge(const Descriptor* descriptor, PyObject* py_message,
+                   PyObject* value) {
+  CMessage* cmessage = reinterpret_cast<CMessage*>(py_message);
+  AssureWritable(cmessage);
+  if (PyObject_TypeCheck(value, CMessage_Type)) {
+    ScopedPyObjectPtr merged(MergeFrom(cmessage, value));
+    if (merged == nullptr) {
+      return -1;
+    }
+    return 0;
+  }
+  if (PyDict_Check(value) &&
+      (descriptor->well_known_type() == Descriptor::WELLKNOWNTYPE_STRUCT)) {
+    ScopedPyObjectPtr ok(PyObject_CallMethod(py_message, "update", "O", value));
+    if (ok.get() == nullptr && PyDict_Size(value) == 1) {
+      ScopedPyObjectPtr fields_str(PyUnicode_FromString("fields"));
+      if (PyDict_Contains(value, fields_str.get())) {
+        // Fallback to init as normal message field.
+        PyErr_Clear();
+        PyObject* tmp = Clear(cmessage);
+        Py_DECREF(tmp);
+        if (InitAttributes(cmessage, nullptr, value) < 0) {
+          return -1;
+        }
+      }
+    }
+    return 0;
+  }
+
+  if (descriptor->well_known_type() != Descriptor::WELLKNOWNTYPE_UNSPECIFIED &&
+      PyObject_HasAttrString(py_message, "_internal_assign")) {
+    ScopedPyObjectPtr ok(
+        PyObject_CallMethod(py_message, "_internal_assign", "O", value));
+    if (ok.get() == nullptr) {
+      return -1;
+    }
+    return 0;
+  }
+
+  PyErr_Format(PyExc_TypeError,
+               "Parameter to initialize message field must be "
+               "dict or instance of same class: expected %s got %s.",
+               std::string(descriptor->full_name()).c_str(),
+               Py_TYPE(value)->tp_name);
+  return -1;
+}
+
 // Initializes fields of a message. Used in constructors.
 int InitAttributes(CMessage* self, PyObject* args, PyObject* kwargs) {
   if (args != nullptr && PyTuple_Size(args) != 0) {
@@ -1084,20 +1131,22 @@ int InitAttributes(CMessage* self, PyObject* args, PyObject* kwargs) {
         }
         ScopedPyObjectPtr next;
         while ((next.reset(PyIter_Next(iter.get()))) != nullptr) {
-          PyObject* kwargs = (PyDict_Check(next.get()) ? next.get() : nullptr);
-          ScopedPyObjectPtr new_msg(
-              repeated_composite_container::Add(rc_container, nullptr, kwargs));
-          if (new_msg == nullptr) {
-            return -1;
-          }
-          if (kwargs == nullptr) {
-            // next was not a dict, it's a message we need to merge
-            ScopedPyObjectPtr merged(MergeFrom(
-                reinterpret_cast<CMessage*>(new_msg.get()), next.get()));
-            if (merged.get() == nullptr) {
+          if ((PyDict_Check(next.get())) &&
+              (descriptor->message_type()->well_known_type() !=
+               Descriptor::WELLKNOWNTYPE_STRUCT)) {
+            ScopedPyObjectPtr new_msg(repeated_composite_container::Add(
+                rc_container, nullptr, next.get()));
+            if (new_msg == nullptr) {
               return -1;
             }
+            continue;
           }
+          ScopedPyObjectPtr new_msg(repeated_composite_container::Add(
+              rc_container, nullptr, nullptr));
+          if (new_msg == nullptr) {
+            return -1;
+          }
+          InitWKTOrMerge(descriptor->message_type(), new_msg.get(), next.get());
         }
         if (PyErr_Occurred()) {
           // Check to see how PyIter_Next() exited.
@@ -1142,53 +1191,19 @@ int InitAttributes(CMessage* self, PyObject* args, PyObject* kwargs) {
         return -1;
       }
       CMessage* cmessage = reinterpret_cast<CMessage*>(message.get());
-      if (PyDict_Check(value)) {
+      if (PyDict_Check(value) &&
+          (descriptor->message_type()->well_known_type() !=
+           Descriptor::WELLKNOWNTYPE_STRUCT)) {
         // Make the message exist even if the dict is empty.
         AssureWritable(cmessage);
-        if (descriptor->message_type()->well_known_type() ==
-            Descriptor::WELLKNOWNTYPE_STRUCT) {
-          ScopedPyObjectPtr ok(PyObject_CallMethod(
-              reinterpret_cast<PyObject*>(cmessage), "update", "O", value));
-          if (ok.get() == nullptr && PyDict_Size(value) == 1) {
-            ScopedPyObjectPtr fields_str(PyUnicode_FromString("fields"));
-            if (PyDict_Contains(value, fields_str.get())) {
-              // Fallback to init as normal message field.
-              PyErr_Clear();
-              PyObject* tmp = Clear(cmessage);
-              Py_DECREF(tmp);
-              if (InitAttributes(cmessage, nullptr, value) < 0) {
-                return -1;
-              }
-            }
-          }
-        } else {
-          if (InitAttributes(cmessage, nullptr, value) < 0) {
-            return -1;
-          }
-        }
-      } else if (PyObject_TypeCheck(value, CMessage_Type)) {
-        ScopedPyObjectPtr merged(MergeFrom(cmessage, value));
-        if (merged == nullptr) {
+        if (InitAttributes(cmessage, nullptr, value) < 0) {
           return -1;
         }
-      } else if (descriptor->message_type()->well_known_type() !=
-                     Descriptor::WELLKNOWNTYPE_UNSPECIFIED &&
-                 PyObject_HasAttrString(reinterpret_cast<PyObject*>(cmessage),
-                                        "_internal_assign")) {
-        AssureWritable(cmessage);
-        ScopedPyObjectPtr ok(
-            PyObject_CallMethod(reinterpret_cast<PyObject*>(cmessage),
-                                "_internal_assign", "O", value));
-        if (ok.get() == nullptr) {
+      } else {
+        if (InitWKTOrMerge(descriptor->message_type(), message.get(), value) <
+            0) {
           return -1;
         }
-      } else {
-        PyErr_Format(PyExc_TypeError,
-                     "Parameter to initialize message field must be "
-                     "dict or instance of same class: expected %s got %s.",
-                     std::string(descriptor->full_name()).c_str(),
-                     Py_TYPE(value)->tp_name);
-        return -1;
       }
     } else {
       ScopedPyObjectPtr new_val;