[Python] Improve python API (#8781)

* Fix generate_code script path * [Python] Make StartVector public Make StartVector vector public since it is already being used in generated code * [Python] Improve vector creation for Python API Makes Python API for vectors cleaner like Rust and Swift --------- Co-authored-by: Derek Bailey <derekbailey@google.com>
2026-06-01 19:58:15 +00:00 · 2026-01-20 17:01:20 -08:00
parent 0d67abde45
commit af8997b567
20 changed files with 622 additions and 88 deletions
--- a/docs/source/tutorial.md
+++ b/docs/source/tutorial.md
@@ -1134,12 +1134,8 @@ The Builder provides multiple ways to create `vectors`.
 === "Python"

    ```py
-    # Create a FlatBuffer vector and prepend the weapons.
-    # Note: Since we prepend the data, prepend them in reverse order.
-    MyGame.Sample.Monster.StartWeaponsVector(builder, 2)
-    builder.PrependUOffsetTRelative(axe)
-    builder.PrependUOffsetTRelative(sword)
-    weapons = builder.EndVector()
+    # Use the generated helper to create the weapons vector from offsets.
+    weapons = MyGame.Sample.Monster.CreateWeaponsVector(builder, [sword, axe])
    ```

 === "Rust"
@@ -1352,16 +1348,13 @@ bit more directly.
    ```py
    # Create a `vector` representing the inventory of the Orc. Each number
    # could correspond to an item that can be claimed after he is slain.
-    # Note: Since we prepend the bytes, this loop iterates in reverse.
-    MyGame.Sample.Monster.StartInventoryVector(builder, 10)
-    for i in reversed(range(0, 10)):
-        builder.PrependByte(i)
-    inv = builder.EndVector()
+    inv = MyGame.Sample.Monster.CreateInventoryVector(builder, range(0, 10))

-    MyGame.Sample.Monster.StartPathVector(builder, 2)
-    MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0)
-    MyGame.Sample.Vec3.CreateVec3(builder, 4.0, 5.0, 6.0)
-    path = builder.EndVector()
+    path_points = [
+        MyGame.Sample.Vec3T(x=1.0, y=2.0, z=3.0),
+        MyGame.Sample.Vec3T(x=4.0, y=5.0, z=6.0),
+    ]
+    path = MyGame.Sample.Monster.CreatePathVector(builder, path_points)
    ```

 === "Rust"
--- a/goldens/py/flatbuffers/goldens/Universe.py
+++ b/goldens/py/flatbuffers/goldens/Universe.py
@@ -80,6 +80,12 @@ def UniverseStartGalaxiesVector(builder, numElems):
 def StartGalaxiesVector(builder, numElems):
    return UniverseStartGalaxiesVector(builder, numElems)

+def UniverseCreateGalaxiesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateGalaxiesVector(builder, data):
+    UniverseCreateGalaxiesVector(builder, data)
+
 def UniverseEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/builder.py
+++ b/python/flatbuffers/builder.py
@@ -422,7 +422,6 @@ class Builder(object):
    off2 = self.Offset() - off + N.UOffsetTFlags.bytewidth
    self.PlaceUOffsetT(off2)

-  ## @cond FLATBUFFERS_INTERNAL
  def StartVector(self, elemSize, numElems, alignment):
    """StartVector initializes bookkeeping for writing a new vector.

@@ -438,8 +437,6 @@ class Builder(object):
    self.Prep(alignment, elemSize * numElems)  # In case alignment > int.
    return self.Offset()

-  ## @endcond
-
  def EndVector(self, numElems=None):
    """EndVector writes data necessary to finish vector construction."""

@@ -556,6 +553,21 @@ class Builder(object):
    self.vectorNumElems = x.size
    return self.EndVector()

+  def CreateVectorOfTables(self, offsets):
+    """CreateVectorOfTables writes a vector of offsets such as tables or strings.
+
+    Args:
+      offsets: Iterable of offsets returned from previous builder operations.
+               Each element should be an integer compatible with UOffsetT.
+    """
+
+    offsets = list(offsets)
+    self.StartVector(N.UOffsetTFlags.bytewidth, len(offsets),
+                     N.UOffsetTFlags.bytewidth)
+    for off in reversed(offsets):
+      self.PrependUOffsetTRelative(off)
+    return self.EndVector()
+
  ## @cond FLATBUFFERS_INTERNAL
  def assertNested(self):
    """Check that we are in the process of building an object."""
--- a/python/flatbuffers/reflection/Enum.py
+++ b/python/flatbuffers/reflection/Enum.py
@@ -155,6 +155,12 @@ def EnumStartValuesVector(builder, numElems):
 def StartValuesVector(builder, numElems):
    return EnumStartValuesVector(builder, numElems)

+def EnumCreateValuesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateValuesVector(builder, data):
+    EnumCreateValuesVector(builder, data)
+
 def EnumAddIsUnion(builder, isUnion):
    builder.PrependBoolSlot(2, isUnion, 0)

@@ -179,6 +185,12 @@ def EnumStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return EnumStartAttributesVector(builder, numElems)

+def EnumCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    EnumCreateAttributesVector(builder, data)
+
 def EnumAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -191,6 +203,12 @@ def EnumStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return EnumStartDocumentationVector(builder, numElems)

+def EnumCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    EnumCreateDocumentationVector(builder, data)
+
 def EnumAddDeclarationFile(builder, declarationFile):
    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)

--- a/python/flatbuffers/reflection/EnumVal.py
+++ b/python/flatbuffers/reflection/EnumVal.py
@@ -134,6 +134,12 @@ def EnumValStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return EnumValStartDocumentationVector(builder, numElems)

+def EnumValCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    EnumValCreateDocumentationVector(builder, data)
+
 def EnumValAddAttributes(builder, attributes):
    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)

@@ -146,6 +152,12 @@ def EnumValStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return EnumValStartAttributesVector(builder, numElems)

+def EnumValCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    EnumValCreateAttributesVector(builder, data)
+
 def EnumValEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/reflection/Field.py
+++ b/python/flatbuffers/reflection/Field.py
@@ -235,6 +235,12 @@ def FieldStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return FieldStartAttributesVector(builder, numElems)

+def FieldCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    FieldCreateAttributesVector(builder, data)
+
 def FieldAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -247,6 +253,12 @@ def FieldStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return FieldStartDocumentationVector(builder, numElems)

+def FieldCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    FieldCreateDocumentationVector(builder, data)
+
 def FieldAddOptional(builder, optional):
    builder.PrependBoolSlot(11, optional, 0)

--- a/python/flatbuffers/reflection/Object.py
+++ b/python/flatbuffers/reflection/Object.py
@@ -158,6 +158,12 @@ def ObjectStartFieldsVector(builder, numElems):
 def StartFieldsVector(builder, numElems):
    return ObjectStartFieldsVector(builder, numElems)

+def ObjectCreateFieldsVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateFieldsVector(builder, data):
+    ObjectCreateFieldsVector(builder, data)
+
 def ObjectAddIsStruct(builder, isStruct):
    builder.PrependBoolSlot(2, isStruct, 0)

@@ -188,6 +194,12 @@ def ObjectStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return ObjectStartAttributesVector(builder, numElems)

+def ObjectCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    ObjectCreateAttributesVector(builder, data)
+
 def ObjectAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -200,6 +212,12 @@ def ObjectStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return ObjectStartDocumentationVector(builder, numElems)

+def ObjectCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    ObjectCreateDocumentationVector(builder, data)
+
 def ObjectAddDeclarationFile(builder, declarationFile):
    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)

--- a/python/flatbuffers/reflection/RPCCall.py
+++ b/python/flatbuffers/reflection/RPCCall.py
@@ -138,6 +138,12 @@ def RPCCallStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return RPCCallStartAttributesVector(builder, numElems)

+def RPCCallCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    RPCCallCreateAttributesVector(builder, data)
+
 def RPCCallAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -150,6 +156,12 @@ def RPCCallStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return RPCCallStartDocumentationVector(builder, numElems)

+def RPCCallCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    RPCCallCreateDocumentationVector(builder, data)
+
 def RPCCallEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/reflection/Schema.py
+++ b/python/flatbuffers/reflection/Schema.py
@@ -180,6 +180,12 @@ def SchemaStartObjectsVector(builder, numElems):
 def StartObjectsVector(builder, numElems):
    return SchemaStartObjectsVector(builder, numElems)

+def SchemaCreateObjectsVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateObjectsVector(builder, data):
+    SchemaCreateObjectsVector(builder, data)
+
 def SchemaAddEnums(builder, enums):
    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)

@@ -192,6 +198,12 @@ def SchemaStartEnumsVector(builder, numElems):
 def StartEnumsVector(builder, numElems):
    return SchemaStartEnumsVector(builder, numElems)

+def SchemaCreateEnumsVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateEnumsVector(builder, data):
+    SchemaCreateEnumsVector(builder, data)
+
 def SchemaAddFileIdent(builder, fileIdent):
    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)

@@ -222,6 +234,12 @@ def SchemaStartServicesVector(builder, numElems):
 def StartServicesVector(builder, numElems):
    return SchemaStartServicesVector(builder, numElems)

+def SchemaCreateServicesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateServicesVector(builder, data):
+    SchemaCreateServicesVector(builder, data)
+
 def SchemaAddAdvancedFeatures(builder, advancedFeatures):
    builder.PrependUint64Slot(6, advancedFeatures, 0)

@@ -240,6 +258,12 @@ def SchemaStartFbsFilesVector(builder, numElems):
 def StartFbsFilesVector(builder, numElems):
    return SchemaStartFbsFilesVector(builder, numElems)

+def SchemaCreateFbsFilesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateFbsFilesVector(builder, data):
+    SchemaCreateFbsFilesVector(builder, data)
+
 def SchemaEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/reflection/SchemaFile.py
+++ b/python/flatbuffers/reflection/SchemaFile.py
@@ -84,6 +84,12 @@ def SchemaFileStartIncludedFilenamesVector(builder, numElems):
 def StartIncludedFilenamesVector(builder, numElems):
    return SchemaFileStartIncludedFilenamesVector(builder, numElems)

+def SchemaFileCreateIncludedFilenamesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateIncludedFilenamesVector(builder, data):
+    SchemaFileCreateIncludedFilenamesVector(builder, data)
+
 def SchemaFileEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/reflection/Service.py
+++ b/python/flatbuffers/reflection/Service.py
@@ -137,6 +137,12 @@ def ServiceStartCallsVector(builder, numElems):
 def StartCallsVector(builder, numElems):
    return ServiceStartCallsVector(builder, numElems)

+def ServiceCreateCallsVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateCallsVector(builder, data):
+    ServiceCreateCallsVector(builder, data)
+
 def ServiceAddAttributes(builder, attributes):
    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)

@@ -149,6 +155,12 @@ def ServiceStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return ServiceStartAttributesVector(builder, numElems)

+def ServiceCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    ServiceCreateAttributesVector(builder, data)
+
 def ServiceAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -161,6 +173,12 @@ def ServiceStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return ServiceStartDocumentationVector(builder, numElems)

+def ServiceCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    ServiceCreateDocumentationVector(builder, data)
+
 def ServiceAddDeclarationFile(builder, declarationFile):
    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)

--- a/scripts/check_generate_code.py
+++ b/scripts/check_generate_code.py
@@ -33,11 +33,11 @@ result = subprocess.run(
 if result.returncode != 0:
  print(
      "\n"
-      "ERROR: *********************************************************\n"
-      "ERROR: * The following differences were found after building.  *\n"
-      "ERROR: * Perhaps there is a difference in the flags for the.   *\n"
-      "ERROR: * CMakeLists.txt vs the script/generate_code.py script? *\n"
-      "ERROR: *********************************************************\n"
+      "ERROR: **********************************************************\n"
+      "ERROR: * The following differences were found after building.   *\n"
+      "ERROR: * Perhaps there is a difference in the flags for the.    *\n"
+      "ERROR: * CMakeLists.txt vs the scripts/generate_code.py script? *\n"
+      "ERROR: **********************************************************\n"
  )
  subprocess.run(["git", "diff", "--binary", "--exit-code"], cwd=root_path)
  sys.exit(result.returncode)
@@ -55,11 +55,11 @@ result = subprocess.run(
 if result.returncode != 0:
  print(
      "\n"
-      "ERROR: ********************************************************\n"
-      "ERROR: * The following differences were found after running   *\n"
-      "ERROR: * the script/generate_code.py script. Maybe you forgot *\n"
-      "ERROR: * to run it after making changes in a generator?       *\n"
-      "ERROR: ********************************************************\n"
+      "ERROR: *********************************************************\n"
+      "ERROR: * The following differences were found after running    *\n"
+      "ERROR: * the scripts/generate_code.py script. Maybe you forgot *\n"
+      "ERROR: * to run it after making changes in a generator?        *\n"
+      "ERROR: *********************************************************\n"
  )
  subprocess.run(["git", "diff", "--binary", "--exit-code"], cwd=root_path)
  sys.exit(result.returncode)
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -593,6 +593,18 @@ class PythonStubGenerator {
                    "bytes) -> uoffset: ...\n";
          }
        }
+
+        stub << "def ";
+        if (!parser_.opts.python_no_type_prefix_suffix) stub << type;
+        stub << "Create" << namer_.Method(*field)
+             << "Vector(builder: flatbuffers.Builder, data: typing.Iterable["
+                "typing.Any]) -> uoffset: ...\n";
+        if (!parser_.opts.one_file &&
+            !parser_.opts.python_no_type_prefix_suffix) {
+          stub << "def Create" << namer_.Method(*field)
+               << "Vector(builder: flatbuffers.Builder, data: "
+                  "typing.Iterable[typing.Any]) -> uoffset: ...\n";
+        }
      }
    }

@@ -1467,6 +1479,59 @@ class PythonGenerator : public BaseGenerator {
    }
  }

+  void BuildVectorCreationHelper(const StructDef& struct_def,
+                                 const FieldDef& field, std::string* code_ptr,
+                                 ImportMap& imports) const {
+    auto& code = *code_ptr;
+    const auto vector_type = field.value.type.VectorType();
+    const bool is_struct_vector = IsStruct(vector_type);
+    const bool is_scalar_vector =
+        IsScalar(vector_type.base_type) || vector_type.enum_def != nullptr;
+    const std::string struct_type = namer_.Type(struct_def);
+    const std::string field_method = namer_.Method(field);
+    const std::string helper_name =
+        parser_.opts.python_no_type_prefix_suffix
+            ? "Create" + field_method + "Vector"
+            : struct_type + "Create" + field_method + "Vector";
+
+    if (parser_.opts.python_typing) {
+      imports.insert(ImportMapEntry{"typing", "Iterable"});
+      code += "def " + helper_name +
+              "(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:\n";
+    } else {
+      code += "def " + helper_name + "(builder, data):\n";
+    }
+
+    if (is_scalar_vector || is_struct_vector) {
+      auto alignment = InlineAlignment(vector_type);
+      auto elem_size = InlineSize(vector_type);
+      code += Indent + "data = list(data)\n";
+      code += Indent + "builder.StartVector(" + NumToString(elem_size) +
+              ", len(data), " + NumToString(alignment) + ")\n";
+      code += Indent + "for item in reversed(data):\n";
+      if (is_struct_vector) {
+        code += Indent + Indent + "item.Pack(builder)\n";
+      } else {
+        code += Indent + Indent + "builder.Prepend" +
+                namer_.Method(GenTypeBasic(vector_type)) + "(item)\n";
+      }
+      code += Indent + "return builder.EndVector()\n\n";
+    } else {
+      code += Indent + "return builder.CreateVectorOfTables(data)\n\n";
+    }
+
+    if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
+      if (parser_.opts.python_typing) {
+        code += "def Create" + field_method +
+                "Vector(builder: flatbuffers.Builder, data: Iterable[Any]) "
+                "-> int:\n";
+      } else {
+        code += "def Create" + field_method + "Vector(builder, data):\n";
+      }
+      code += Indent + helper_name + "(builder, data)\n\n";
+    }
+  }
+
  // Set the value of one of the members of a table's vector and fills in the
  // elements from a bytearray. This is for simplifying the use of nested
  // flatbuffers.
@@ -1617,8 +1682,8 @@ class PythonGenerator : public BaseGenerator {
  }

  // Generate table constructors, conditioned on its members' types.
-  void GenTableBuilders(const StructDef& struct_def,
-                        std::string* code_ptr) const {
+  void GenTableBuilders(const StructDef& struct_def, std::string* code_ptr,
+                        ImportMap& imports) const {
    GetStartOfTable(struct_def, code_ptr);

    for (auto it = struct_def.fields.vec.begin();
@@ -1630,6 +1695,7 @@ class PythonGenerator : public BaseGenerator {
      BuildFieldOfTable(struct_def, field, offset, code_ptr);
      if (IsVector(field.value.type)) {
        BuildVectorOfTable(struct_def, field, code_ptr);
+        BuildVectorCreationHelper(struct_def, field, code_ptr, imports);
        BuildVectorOfTableFromBytes(struct_def, field, code_ptr);
      }
    }
@@ -1696,7 +1762,7 @@ class PythonGenerator : public BaseGenerator {
      GenStructBuilder(struct_def, code_ptr);
    } else {
      // Creates a set of functions that allow table construction.
-      GenTableBuilders(struct_def, code_ptr);
+      GenTableBuilders(struct_def, code_ptr, imports);
    }
  }

--- a/tests/MyGame/Example/Monster.py
+++ b/tests/MyGame/Example/Monster.py
@@ -914,6 +914,16 @@ def MonsterStartInventoryVector(builder, numElems):
 def StartInventoryVector(builder, numElems):
    return MonsterStartInventoryVector(builder, numElems)

+def MonsterCreateInventoryVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateInventoryVector(builder, data):
+    MonsterCreateInventoryVector(builder, data)
+
 def MonsterAddColor(builder, color):
    builder.PrependUint8Slot(6, color, 8)

@@ -944,6 +954,16 @@ def MonsterStartTest4Vector(builder, numElems):
 def StartTest4Vector(builder, numElems):
    return MonsterStartTest4Vector(builder, numElems)

+def MonsterCreateTest4Vector(builder, data):
+    data = list(data)
+    builder.StartVector(4, len(data), 2)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
+def CreateTest4Vector(builder, data):
+    MonsterCreateTest4Vector(builder, data)
+
 def MonsterAddTestarrayofstring(builder, testarrayofstring):
    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)

@@ -956,6 +976,12 @@ def MonsterStartTestarrayofstringVector(builder, numElems):
 def StartTestarrayofstringVector(builder, numElems):
    return MonsterStartTestarrayofstringVector(builder, numElems)

+def MonsterCreateTestarrayofstringVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateTestarrayofstringVector(builder, data):
+    MonsterCreateTestarrayofstringVector(builder, data)
+
 def MonsterAddTestarrayoftables(builder, testarrayoftables):
    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)

@@ -968,6 +994,12 @@ def MonsterStartTestarrayoftablesVector(builder, numElems):
 def StartTestarrayoftablesVector(builder, numElems):
    return MonsterStartTestarrayoftablesVector(builder, numElems)

+def MonsterCreateTestarrayoftablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateTestarrayoftablesVector(builder, data):
+    MonsterCreateTestarrayoftablesVector(builder, data)
+
 def MonsterAddEnemy(builder, enemy):
    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)

@@ -986,6 +1018,16 @@ def MonsterStartTestnestedflatbufferVector(builder, numElems):
 def StartTestnestedflatbufferVector(builder, numElems):
    return MonsterStartTestnestedflatbufferVector(builder, numElems)

+def MonsterCreateTestnestedflatbufferVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateTestnestedflatbufferVector(builder, data):
+    MonsterCreateTestnestedflatbufferVector(builder, data)
+
 def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
    builder.StartVector(1, len(bytes), 1)
    builder.head = builder.head - len(bytes)
@@ -1065,6 +1107,16 @@ def MonsterStartTestarrayofboolsVector(builder, numElems):
 def StartTestarrayofboolsVector(builder, numElems):
    return MonsterStartTestarrayofboolsVector(builder, numElems)

+def MonsterCreateTestarrayofboolsVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependBool(item)
+    return builder.EndVector()
+
+def CreateTestarrayofboolsVector(builder, data):
+    MonsterCreateTestarrayofboolsVector(builder, data)
+
 def MonsterAddTestf(builder, testf):
    builder.PrependFloat32Slot(25, testf, 3.14159)

@@ -1095,6 +1147,12 @@ def MonsterStartTestarrayofstring2Vector(builder, numElems):
 def StartTestarrayofstring2Vector(builder, numElems):
    return MonsterStartTestarrayofstring2Vector(builder, numElems)

+def MonsterCreateTestarrayofstring2Vector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateTestarrayofstring2Vector(builder, data):
+    MonsterCreateTestarrayofstring2Vector(builder, data)
+
 def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
    builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)

@@ -1107,6 +1165,16 @@ def MonsterStartTestarrayofsortedstructVector(builder, numElems):
 def StartTestarrayofsortedstructVector(builder, numElems):
    return MonsterStartTestarrayofsortedstructVector(builder, numElems)

+def MonsterCreateTestarrayofsortedstructVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 4)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
+def CreateTestarrayofsortedstructVector(builder, data):
+    MonsterCreateTestarrayofsortedstructVector(builder, data)
+
 def MonsterAddFlex(builder, flex):
    builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)

@@ -1119,6 +1187,16 @@ def MonsterStartFlexVector(builder, numElems):
 def StartFlexVector(builder, numElems):
    return MonsterStartFlexVector(builder, numElems)

+def MonsterCreateFlexVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateFlexVector(builder, data):
+    MonsterCreateFlexVector(builder, data)
+
 def MonsterAddTest5(builder, test5):
    builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)

@@ -1131,6 +1209,16 @@ def MonsterStartTest5Vector(builder, numElems):
 def StartTest5Vector(builder, numElems):
    return MonsterStartTest5Vector(builder, numElems)

+def MonsterCreateTest5Vector(builder, data):
+    data = list(data)
+    builder.StartVector(4, len(data), 2)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
+def CreateTest5Vector(builder, data):
+    MonsterCreateTest5Vector(builder, data)
+
 def MonsterAddVectorOfLongs(builder, vectorOfLongs):
    builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)

@@ -1143,6 +1231,16 @@ def MonsterStartVectorOfLongsVector(builder, numElems):
 def StartVectorOfLongsVector(builder, numElems):
    return MonsterStartVectorOfLongsVector(builder, numElems)

+def MonsterCreateVectorOfLongsVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependInt64(item)
+    return builder.EndVector()
+
+def CreateVectorOfLongsVector(builder, data):
+    MonsterCreateVectorOfLongsVector(builder, data)
+
 def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
    builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)

@@ -1155,6 +1253,16 @@ def MonsterStartVectorOfDoublesVector(builder, numElems):
 def StartVectorOfDoublesVector(builder, numElems):
    return MonsterStartVectorOfDoublesVector(builder, numElems)

+def MonsterCreateVectorOfDoublesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
+def CreateVectorOfDoublesVector(builder, data):
+    MonsterCreateVectorOfDoublesVector(builder, data)
+
 def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)

@@ -1173,6 +1281,12 @@ def MonsterStartVectorOfReferrablesVector(builder, numElems):
 def StartVectorOfReferrablesVector(builder, numElems):
    return MonsterStartVectorOfReferrablesVector(builder, numElems)

+def MonsterCreateVectorOfReferrablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateVectorOfReferrablesVector(builder, data):
+    MonsterCreateVectorOfReferrablesVector(builder, data)
+
 def MonsterAddSingleWeakReference(builder, singleWeakReference):
    builder.PrependUint64Slot(36, singleWeakReference, 0)

@@ -1191,6 +1305,16 @@ def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
 def StartVectorOfWeakReferencesVector(builder, numElems):
    return MonsterStartVectorOfWeakReferencesVector(builder, numElems)

+def MonsterCreateVectorOfWeakReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
+def CreateVectorOfWeakReferencesVector(builder, data):
+    MonsterCreateVectorOfWeakReferencesVector(builder, data)
+
 def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
    builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)

@@ -1203,6 +1327,12 @@ def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
 def StartVectorOfStrongReferrablesVector(builder, numElems):
    return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)

+def MonsterCreateVectorOfStrongReferrablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateVectorOfStrongReferrablesVector(builder, data):
+    MonsterCreateVectorOfStrongReferrablesVector(builder, data)
+
 def MonsterAddCoOwningReference(builder, coOwningReference):
    builder.PrependUint64Slot(39, coOwningReference, 0)

@@ -1221,6 +1351,16 @@ def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
 def StartVectorOfCoOwningReferencesVector(builder, numElems):
    return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)

+def MonsterCreateVectorOfCoOwningReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
+def CreateVectorOfCoOwningReferencesVector(builder, data):
+    MonsterCreateVectorOfCoOwningReferencesVector(builder, data)
+
 def MonsterAddNonOwningReference(builder, nonOwningReference):
    builder.PrependUint64Slot(41, nonOwningReference, 0)

@@ -1239,6 +1379,16 @@ def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
 def StartVectorOfNonOwningReferencesVector(builder, numElems):
    return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)

+def MonsterCreateVectorOfNonOwningReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
+def CreateVectorOfNonOwningReferencesVector(builder, data):
+    MonsterCreateVectorOfNonOwningReferencesVector(builder, data)
+
 def MonsterAddAnyUniqueType(builder, anyUniqueType):
    builder.PrependUint8Slot(43, anyUniqueType, 0)

@@ -1275,6 +1425,16 @@ def MonsterStartVectorOfEnumsVector(builder, numElems):
 def StartVectorOfEnumsVector(builder, numElems):
    return MonsterStartVectorOfEnumsVector(builder, numElems)

+def MonsterCreateVectorOfEnumsVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateVectorOfEnumsVector(builder, data):
+    MonsterCreateVectorOfEnumsVector(builder, data)
+
 def MonsterAddSignedEnum(builder, signedEnum):
    builder.PrependInt8Slot(48, signedEnum, -1)

@@ -1293,6 +1453,16 @@ def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
 def StartTestrequirednestedflatbufferVector(builder, numElems):
    return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)

+def MonsterCreateTestrequirednestedflatbufferVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateTestrequirednestedflatbufferVector(builder, data):
+    MonsterCreateTestrequirednestedflatbufferVector(builder, data)
+
 def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
    builder.StartVector(1, len(bytes), 1)
    builder.head = builder.head - len(bytes)
@@ -1312,6 +1482,12 @@ def MonsterStartScalarKeySortedTablesVector(builder, numElems):
 def StartScalarKeySortedTablesVector(builder, numElems):
    return MonsterStartScalarKeySortedTablesVector(builder, numElems)

+def MonsterCreateScalarKeySortedTablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateScalarKeySortedTablesVector(builder, data):
+    MonsterCreateScalarKeySortedTablesVector(builder, data)
+
 def MonsterAddNativeInline(builder, nativeInline):
    builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)

--- a/tests/MyGame/Example/TypeAliases.py
+++ b/tests/MyGame/Example/TypeAliases.py
@@ -230,6 +230,16 @@ def TypeAliasesStartV8Vector(builder, numElems):
 def StartV8Vector(builder, numElems):
    return TypeAliasesStartV8Vector(builder, numElems)

+def TypeAliasesCreateV8Vector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependInt8(item)
+    return builder.EndVector()
+
+def CreateV8Vector(builder, data):
+    TypeAliasesCreateV8Vector(builder, data)
+
 def TypeAliasesAddVf64(builder, vf64):
    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)

@@ -242,6 +252,16 @@ def TypeAliasesStartVf64Vector(builder, numElems):
 def StartVf64Vector(builder, numElems):
    return TypeAliasesStartVf64Vector(builder, numElems)

+def TypeAliasesCreateVf64Vector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
+def CreateVf64Vector(builder, data):
+    TypeAliasesCreateVf64Vector(builder, data)
+
 def TypeAliasesEnd(builder):
    return builder.EndObject()

--- a/tests/MyGame/MonsterExtra.py
+++ b/tests/MyGame/MonsterExtra.py
@@ -5,6 +5,7 @@
 import flatbuffers
 from flatbuffers.compat import import_numpy
 from typing import Any
+from typing import Iterable
 np = import_numpy()

 class MonsterExtra(object):
@@ -205,6 +206,16 @@ def MonsterExtraStartDvecVector(builder, numElems: int) -> int:
 def StartDvecVector(builder, numElems: int) -> int:
    return MonsterExtraStartDvecVector(builder, numElems)

+def MonsterExtraCreateDvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
+def CreateDvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
+    MonsterExtraCreateDvecVector(builder, data)
+
 def MonsterExtraAddFvec(builder: flatbuffers.Builder, fvec: int):
    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)

@@ -217,6 +228,16 @@ def MonsterExtraStartFvecVector(builder, numElems: int) -> int:
 def StartFvecVector(builder, numElems: int) -> int:
    return MonsterExtraStartFvecVector(builder, numElems)

+def MonsterExtraCreateFvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
+    data = list(data)
+    builder.StartVector(4, len(data), 4)
+    for item in reversed(data):
+        builder.PrependFloat32(item)
+    return builder.EndVector()
+
+def CreateFvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
+    MonsterExtraCreateFvecVector(builder, data)
+
 def MonsterExtraEnd(builder: flatbuffers.Builder) -> int:
    return builder.EndObject()

--- a/tests/MyGame/MonsterExtra.pyi
+++ b/tests/MyGame/MonsterExtra.pyi
@@ -77,9 +77,13 @@ def MonsterExtraAddF3(builder: flatbuffers.Builder, f3: float) -> None: ...
 def MonsterExtraAddDvec(builder: flatbuffers.Builder, dvec: uoffset) -> None: ...
 def MonsterExtraStartDvecVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
 def StartDvecVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
+def MonsterExtraCreateDvecVector(builder: flatbuffers.Builder, data: typing.Iterable[typing.Any]) -> uoffset: ...
+def CreateDvecVector(builder: flatbuffers.Builder, data: typing.Iterable[typing.Any]) -> uoffset: ...
 def MonsterExtraAddFvec(builder: flatbuffers.Builder, fvec: uoffset) -> None: ...
 def MonsterExtraStartFvecVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
 def StartFvecVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
+def MonsterExtraCreateFvecVector(builder: flatbuffers.Builder, data: typing.Iterable[typing.Any]) -> uoffset: ...
+def CreateFvecVector(builder: flatbuffers.Builder, data: typing.Iterable[typing.Any]) -> uoffset: ...
 def MonsterExtraEnd(builder: flatbuffers.Builder) -> uoffset: ...
 def End(builder: flatbuffers.Builder) -> uoffset: ...

--- a/tests/monster_test_generated.py
+++ b/tests/monster_test_generated.py
@@ -1761,6 +1761,13 @@ def MonsterAddInventory(builder, inventory):
 def MonsterStartInventoryVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)

+def MonsterCreateInventoryVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterAddColor(builder, color):
    builder.PrependUint8Slot(6, color, 8)

@@ -1776,18 +1783,31 @@ def MonsterAddTest4(builder, test4):
 def MonsterStartTest4Vector(builder, numElems):
    return builder.StartVector(4, numElems, 2)

+def MonsterCreateTest4Vector(builder, data):
+    data = list(data)
+    builder.StartVector(4, len(data), 2)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
 def MonsterAddTestarrayofstring(builder, testarrayofstring):
    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)

 def MonsterStartTestarrayofstringVector(builder, numElems):
    return builder.StartVector(4, numElems, 4)

+def MonsterCreateTestarrayofstringVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddTestarrayoftables(builder, testarrayoftables):
    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)

 def MonsterStartTestarrayoftablesVector(builder, numElems):
    return builder.StartVector(4, numElems, 4)

+def MonsterCreateTestarrayoftablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddEnemy(builder, enemy):
    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)

@@ -1797,6 +1817,13 @@ def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
 def MonsterStartTestnestedflatbufferVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)

+def MonsterCreateTestnestedflatbufferVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
    builder.StartVector(1, len(bytes), 1)
    builder.head = builder.head - len(bytes)
@@ -1838,6 +1865,13 @@ def MonsterAddTestarrayofbools(builder, testarrayofbools):
 def MonsterStartTestarrayofboolsVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)

+def MonsterCreateTestarrayofboolsVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependBool(item)
+    return builder.EndVector()
+
 def MonsterAddTestf(builder, testf):
    builder.PrependFloat32Slot(25, testf, 3.14159)

@@ -1853,36 +1887,74 @@ def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
 def MonsterStartTestarrayofstring2Vector(builder, numElems):
    return builder.StartVector(4, numElems, 4)

+def MonsterCreateTestarrayofstring2Vector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
    builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)

 def MonsterStartTestarrayofsortedstructVector(builder, numElems):
    return builder.StartVector(8, numElems, 4)

+def MonsterCreateTestarrayofsortedstructVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 4)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
 def MonsterAddFlex(builder, flex):
    builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)

 def MonsterStartFlexVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)

+def MonsterCreateFlexVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterAddTest5(builder, test5):
    builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)

 def MonsterStartTest5Vector(builder, numElems):
    return builder.StartVector(4, numElems, 2)

+def MonsterCreateTest5Vector(builder, data):
+    data = list(data)
+    builder.StartVector(4, len(data), 2)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
 def MonsterAddVectorOfLongs(builder, vectorOfLongs):
    builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)

 def MonsterStartVectorOfLongsVector(builder, numElems):
    return builder.StartVector(8, numElems, 8)

+def MonsterCreateVectorOfLongsVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependInt64(item)
+    return builder.EndVector()
+
 def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
    builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)

 def MonsterStartVectorOfDoublesVector(builder, numElems):
    return builder.StartVector(8, numElems, 8)

+def MonsterCreateVectorOfDoublesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
 def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)

@@ -1892,6 +1964,9 @@ def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
 def MonsterStartVectorOfReferrablesVector(builder, numElems):
    return builder.StartVector(4, numElems, 4)

+def MonsterCreateVectorOfReferrablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddSingleWeakReference(builder, singleWeakReference):
    builder.PrependUint64Slot(36, singleWeakReference, 0)

@@ -1901,12 +1976,22 @@ def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
 def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
    return builder.StartVector(8, numElems, 8)

+def MonsterCreateVectorOfWeakReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
 def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
    builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)

 def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
    return builder.StartVector(4, numElems, 4)

+def MonsterCreateVectorOfStrongReferrablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddCoOwningReference(builder, coOwningReference):
    builder.PrependUint64Slot(39, coOwningReference, 0)

@@ -1916,6 +2001,13 @@ def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
 def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
    return builder.StartVector(8, numElems, 8)

+def MonsterCreateVectorOfCoOwningReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
 def MonsterAddNonOwningReference(builder, nonOwningReference):
    builder.PrependUint64Slot(41, nonOwningReference, 0)

@@ -1925,6 +2017,13 @@ def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
 def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
    return builder.StartVector(8, numElems, 8)

+def MonsterCreateVectorOfNonOwningReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
 def MonsterAddAnyUniqueType(builder, anyUniqueType):
    builder.PrependUint8Slot(43, anyUniqueType, 0)

@@ -1943,6 +2042,13 @@ def MonsterAddVectorOfEnums(builder, vectorOfEnums):
 def MonsterStartVectorOfEnumsVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)

+def MonsterCreateVectorOfEnumsVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterAddSignedEnum(builder, signedEnum):
    builder.PrependInt8Slot(48, signedEnum, -1)

@@ -1952,6 +2058,13 @@ def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer
 def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)

+def MonsterCreateTestrequirednestedflatbufferVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
 def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
    builder.StartVector(1, len(bytes), 1)
    builder.head = builder.head - len(bytes)
@@ -1963,6 +2076,9 @@ def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
 def MonsterStartScalarKeySortedTablesVector(builder, numElems):
    return builder.StartVector(4, numElems, 4)

+def MonsterCreateScalarKeySortedTablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
 def MonsterAddNativeInline(builder, nativeInline):
    builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)

@@ -2792,12 +2908,26 @@ def TypeAliasesAddV8(builder, v8):
 def TypeAliasesStartV8Vector(builder, numElems):
    return builder.StartVector(1, numElems, 1)

+def TypeAliasesCreateV8Vector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependInt8(item)
+    return builder.EndVector()
+
 def TypeAliasesAddVf64(builder, vf64):
    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)

 def TypeAliasesStartVf64Vector(builder, numElems):
    return builder.StartVector(8, numElems, 8)

+def TypeAliasesCreateVf64Vector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
 def TypeAliasesEnd(builder):
    return builder.EndObject()

--- a/tests/py_test.py
+++ b/tests/py_test.py
@@ -2200,27 +2200,18 @@ def make_monster_from_generated_code(
  test2 = b.CreateString('test2')
  fred = b.CreateString('Fred')

-  _MONSTER.MonsterStartInventoryVector(b, 5)
-  b.PrependByte(4)
-  b.PrependByte(3)
-  b.PrependByte(2)
-  b.PrependByte(1)
-  b.PrependByte(0)
-  inv = b.EndVector()
+  inv = _MONSTER.MonsterCreateInventoryVector(b, range(5))

  _MONSTER.MonsterStart(b)
  _MONSTER.MonsterAddName(b, fred)
  mon2 = _MONSTER.MonsterEnd(b)

-  _MONSTER.MonsterStartTest4Vector(b, 2)
-  _TEST.CreateTest(b, 10, 20)
-  _TEST.CreateTest(b, 30, 40)
-  test4 = b.EndVector()
+  test4_structs = (_TEST.TestT(10, 20), _TEST.TestT(30, 40))
+  test4 = _MONSTER.MonsterCreateTest4Vector(b, test4_structs)

-  _MONSTER.MonsterStartTestarrayofstringVector(b, 2)
-  b.PrependUOffsetTRelative(test2)
-  b.PrependUOffsetTRelative(test1)
-  testArrayOfString = b.EndVector()
+  testArrayOfString = _MONSTER.MonsterCreateTestarrayofstringVector(
+      b, [test1, test2]
+  )

  _MONSTER.MonsterStartVectorOfLongsVector(b, 5)
  b.PrependInt64(100000000)
--- a/tests/service_test_generated.py
+++ b/tests/service_test_generated.py
@@ -2,61 +2,56 @@

 # namespace: example

-from typing import Any
 import flatbuffers
-
-
 class HelloRequest(object):
-  __slots__ = ['_tab']
+    __slots__ = ['_tab']

-  @classmethod
-  def GetRootAs(cls, buf, offset: int = 0):
-    n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
-    x = HelloRequest()
-    x.Init(buf, n + offset)
-    return x
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = HelloRequest()
+        x.Init(buf, n + offset)
+        return x

-  @classmethod
-  def GetRootAsHelloRequest(cls, buf, offset=0):
-    """This method is deprecated. Please switch to GetRootAs."""
-    return cls.GetRootAs(buf, offset)
+    @classmethod
+    def GetRootAsHelloRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # HelloRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)

-  # HelloRequest
-  def Init(self, buf: bytes, pos: int):
-    self._tab = flatbuffers.table.Table(buf, pos)
+def HelloRequestStart(builder):
+    builder.StartObject(0)

+def HelloRequestEnd(builder):
+    return builder.EndObject()

-def HelloRequestStart(builder: flatbuffers.Builder):
-  builder.StartObject(0)
-
-
-def HelloRequestEnd(builder: flatbuffers.Builder) -> int:
-  return builder.EndObject()


 class HelloResponse(object):
-  __slots__ = ['_tab']
+    __slots__ = ['_tab']

-  @classmethod
-  def GetRootAs(cls, buf, offset: int = 0):
-    n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
-    x = HelloResponse()
-    x.Init(buf, n + offset)
-    return x
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = HelloResponse()
+        x.Init(buf, n + offset)
+        return x

-  @classmethod
-  def GetRootAsHelloResponse(cls, buf, offset=0):
-    """This method is deprecated. Please switch to GetRootAs."""
-    return cls.GetRootAs(buf, offset)
+    @classmethod
+    def GetRootAsHelloResponse(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # HelloResponse
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)

-  # HelloResponse
-  def Init(self, buf: bytes, pos: int):
-    self._tab = flatbuffers.table.Table(buf, pos)
+def HelloResponseStart(builder):
+    builder.StartObject(0)
+
+def HelloResponseEnd(builder):
+    return builder.EndObject()


-def HelloResponseStart(builder: flatbuffers.Builder):
-  builder.StartObject(0)

-
-def HelloResponseEnd(builder: flatbuffers.Builder) -> int:
-  return builder.EndObject()