Optionally generate Python type annotations (#7858)

* optionally generate type prefixes and suffixes for python code

* fix codegen error when qualified name is empty

* WIP: Python typing

* more progress towards python typing

* Further iterate on Python generated code typing

* clang-format

* Regenerate code

* add documentation for Python type annotations option

* generate code with Python type annotations

* handle forward references

* clang-format

grpc/examples/python/greeter/models/HelloReply.py

@@ -32,16 +32,16 @@ class HelloReply(object):
         return None
 
 def HelloReplyStart(builder):
-    return builder.StartObject(1)
+    builder.StartObject(1)
 
 def Start(builder):
-    return HelloReplyStart(builder)
+    HelloReplyStart(builder)
 
 def HelloReplyAddMessage(builder, message):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
 
-def AddMessage(builder, message):
+def AddMessage(builder: flatbuffers.Builder, message: int):
-    return HelloReplyAddMessage(builder, message)
+    HelloReplyAddMessage(builder, message)
 
 def HelloReplyEnd(builder):
     return builder.EndObject()

grpc/examples/python/greeter/models/HelloRequest.py

@@ -32,16 +32,16 @@ class HelloRequest(object):
         return None
 
 def HelloRequestStart(builder):
-    return builder.StartObject(1)
+    builder.StartObject(1)
 
 def Start(builder):
-    return HelloRequestStart(builder)
+    HelloRequestStart(builder)
 
 def HelloRequestAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return HelloRequestAddName(builder, name)
+    HelloRequestAddName(builder, name)
 
 def HelloRequestEnd(builder):
     return builder.EndObject()

include/flatbuffers/idl.h

@@ -698,6 +698,7 @@ struct IDLOptions {
   bool require_json_eof;
   bool keep_proto_id;
   bool python_no_type_prefix_suffix;
+  bool python_typing;
   ProtoIdGapAction proto_id_gap_action;
 
   // Possible options for the more general generator below.
@@ -808,6 +809,7 @@ struct IDLOptions {
         require_json_eof(true),
         keep_proto_id(false),
         python_no_type_prefix_suffix(false),
+        python_typing(false),
         proto_id_gap_action(ProtoIdGapAction::WARNING),
         mini_reflect(IDLOptions::kNone),
         require_explicit_ids(false),

python/flatbuffers/reflection/Enum.py

@@ -42,7 +42,7 @@ class Enum(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.EnumVal import EnumVal
+            from .reflection.EnumVal import EnumVal
             obj = EnumVal()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -72,7 +72,7 @@ class Enum(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from reflection.Type import Type
+            from .reflection.Type import Type
             obj = Type()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -85,7 +85,7 @@ class Enum(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.KeyValue import KeyValue
+            from .reflection.KeyValue import KeyValue
             obj = KeyValue()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -132,70 +132,70 @@ class Enum(object):
         return None
 
 def EnumStart(builder):
-    return builder.StartObject(7)
+    builder.StartObject(7)
 
 def Start(builder):
-    return EnumStart(builder)
+    EnumStart(builder)
 
 def EnumAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return EnumAddName(builder, name)
+    EnumAddName(builder, name)
 
 def EnumAddValues(builder, values):
-    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
 
-def AddValues(builder, values):
+def AddValues(builder: flatbuffers.Builder, values: int):
-    return EnumAddValues(builder, values)
+    EnumAddValues(builder, values)
 
 def EnumStartValuesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartValuesVector(builder, numElems):
+def StartValuesVector(builder, numElems: int) -> int:
     return EnumStartValuesVector(builder, numElems)
 
 def EnumAddIsUnion(builder, isUnion):
-    return builder.PrependBoolSlot(2, isUnion, 0)
+    builder.PrependBoolSlot(2, isUnion, 0)
 
-def AddIsUnion(builder, isUnion):
+def AddIsUnion(builder: flatbuffers.Builder, isUnion: bool):
-    return EnumAddIsUnion(builder, isUnion)
+    EnumAddIsUnion(builder, isUnion)
 
 def EnumAddUnderlyingType(builder, underlyingType):
-    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(underlyingType), 0)
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(underlyingType), 0)
 
-def AddUnderlyingType(builder, underlyingType):
+def AddUnderlyingType(builder: flatbuffers.Builder, underlyingType: int):
-    return EnumAddUnderlyingType(builder, underlyingType)
+    EnumAddUnderlyingType(builder, underlyingType)
 
 def EnumAddAttributes(builder, attributes):
-    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
 
-def AddAttributes(builder, attributes):
+def AddAttributes(builder: flatbuffers.Builder, attributes: int):
-    return EnumAddAttributes(builder, attributes)
+    EnumAddAttributes(builder, attributes)
 
 def EnumStartAttributesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartAttributesVector(builder, numElems):
+def StartAttributesVector(builder, numElems: int) -> int:
     return EnumStartAttributesVector(builder, numElems)
 
 def EnumAddDocumentation(builder, documentation):
-    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
-def AddDocumentation(builder, documentation):
+def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
-    return EnumAddDocumentation(builder, documentation)
+    EnumAddDocumentation(builder, documentation)
 
 def EnumStartDocumentationVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartDocumentationVector(builder, numElems):
+def StartDocumentationVector(builder, numElems: int) -> int:
     return EnumStartDocumentationVector(builder, numElems)
 
 def EnumAddDeclarationFile(builder, declarationFile):
-    return builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
 
-def AddDeclarationFile(builder, declarationFile):
+def AddDeclarationFile(builder: flatbuffers.Builder, declarationFile: int):
-    return EnumAddDeclarationFile(builder, declarationFile)
+    EnumAddDeclarationFile(builder, declarationFile)
 
 def EnumEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/EnumVal.py

@@ -47,7 +47,7 @@ class EnumVal(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from reflection.Type import Type
+            from .reflection.Type import Type
             obj = Type()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -80,7 +80,7 @@ class EnumVal(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.KeyValue import KeyValue
+            from .reflection.KeyValue import KeyValue
             obj = KeyValue()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -99,51 +99,51 @@ class EnumVal(object):
         return o == 0
 
 def EnumValStart(builder):
-    return builder.StartObject(6)
+    builder.StartObject(6)
 
 def Start(builder):
-    return EnumValStart(builder)
+    EnumValStart(builder)
 
 def EnumValAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return EnumValAddName(builder, name)
+    EnumValAddName(builder, name)
 
 def EnumValAddValue(builder, value):
-    return builder.PrependInt64Slot(1, value, 0)
+    builder.PrependInt64Slot(1, value, 0)
 
-def AddValue(builder, value):
+def AddValue(builder: flatbuffers.Builder, value: int):
-    return EnumValAddValue(builder, value)
+    EnumValAddValue(builder, value)
 
 def EnumValAddUnionType(builder, unionType):
-    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(unionType), 0)
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(unionType), 0)
 
-def AddUnionType(builder, unionType):
+def AddUnionType(builder: flatbuffers.Builder, unionType: int):
-    return EnumValAddUnionType(builder, unionType)
+    EnumValAddUnionType(builder, unionType)
 
 def EnumValAddDocumentation(builder, documentation):
-    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
-def AddDocumentation(builder, documentation):
+def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
-    return EnumValAddDocumentation(builder, documentation)
+    EnumValAddDocumentation(builder, documentation)
 
 def EnumValStartDocumentationVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartDocumentationVector(builder, numElems):
+def StartDocumentationVector(builder, numElems: int) -> int:
     return EnumValStartDocumentationVector(builder, numElems)
 
 def EnumValAddAttributes(builder, attributes):
-    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
 
-def AddAttributes(builder, attributes):
+def AddAttributes(builder: flatbuffers.Builder, attributes: int):
-    return EnumValAddAttributes(builder, attributes)
+    EnumValAddAttributes(builder, attributes)
 
 def EnumValStartAttributesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartAttributesVector(builder, numElems):
+def StartAttributesVector(builder, numElems: int) -> int:
     return EnumValStartAttributesVector(builder, numElems)
 
 def EnumValEnd(builder):

python/flatbuffers/reflection/Field.py

@@ -40,7 +40,7 @@ class Field(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from reflection.Type import Type
+            from .reflection.Type import Type
             obj = Type()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -102,7 +102,7 @@ class Field(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.KeyValue import KeyValue
+            from .reflection.KeyValue import KeyValue
             obj = KeyValue()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -156,100 +156,100 @@ class Field(object):
         return 0
 
 def FieldStart(builder):
-    return builder.StartObject(13)
+    builder.StartObject(13)
 
 def Start(builder):
-    return FieldStart(builder)
+    FieldStart(builder)
 
 def FieldAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return FieldAddName(builder, name)
+    FieldAddName(builder, name)
 
 def FieldAddType(builder, type):
-    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0)
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0)
 
-def AddType(builder, type):
+def AddType(builder: flatbuffers.Builder, type: int):
-    return FieldAddType(builder, type)
+    FieldAddType(builder, type)
 
 def FieldAddId(builder, id):
-    return builder.PrependUint16Slot(2, id, 0)
+    builder.PrependUint16Slot(2, id, 0)
 
-def AddId(builder, id):
+def AddId(builder: flatbuffers.Builder, id: int):
-    return FieldAddId(builder, id)
+    FieldAddId(builder, id)
 
 def FieldAddOffset(builder, offset):
-    return builder.PrependUint16Slot(3, offset, 0)
+    builder.PrependUint16Slot(3, offset, 0)
 
-def AddOffset(builder, offset):
+def AddOffset(builder: flatbuffers.Builder, offset: int):
-    return FieldAddOffset(builder, offset)
+    FieldAddOffset(builder, offset)
 
 def FieldAddDefaultInteger(builder, defaultInteger):
-    return builder.PrependInt64Slot(4, defaultInteger, 0)
+    builder.PrependInt64Slot(4, defaultInteger, 0)
 
-def AddDefaultInteger(builder, defaultInteger):
+def AddDefaultInteger(builder: flatbuffers.Builder, defaultInteger: int):
-    return FieldAddDefaultInteger(builder, defaultInteger)
+    FieldAddDefaultInteger(builder, defaultInteger)
 
 def FieldAddDefaultReal(builder, defaultReal):
-    return builder.PrependFloat64Slot(5, defaultReal, 0.0)
+    builder.PrependFloat64Slot(5, defaultReal, 0.0)
 
-def AddDefaultReal(builder, defaultReal):
+def AddDefaultReal(builder: flatbuffers.Builder, defaultReal: float):
-    return FieldAddDefaultReal(builder, defaultReal)
+    FieldAddDefaultReal(builder, defaultReal)
 
 def FieldAddDeprecated(builder, deprecated):
-    return builder.PrependBoolSlot(6, deprecated, 0)
+    builder.PrependBoolSlot(6, deprecated, 0)
 
-def AddDeprecated(builder, deprecated):
+def AddDeprecated(builder: flatbuffers.Builder, deprecated: bool):
-    return FieldAddDeprecated(builder, deprecated)
+    FieldAddDeprecated(builder, deprecated)
 
 def FieldAddRequired(builder, required):
-    return builder.PrependBoolSlot(7, required, 0)
+    builder.PrependBoolSlot(7, required, 0)
 
-def AddRequired(builder, required):
+def AddRequired(builder: flatbuffers.Builder, required: bool):
-    return FieldAddRequired(builder, required)
+    FieldAddRequired(builder, required)
 
 def FieldAddKey(builder, key):
-    return builder.PrependBoolSlot(8, key, 0)
+    builder.PrependBoolSlot(8, key, 0)
 
-def AddKey(builder, key):
+def AddKey(builder: flatbuffers.Builder, key: bool):
-    return FieldAddKey(builder, key)
+    FieldAddKey(builder, key)
 
 def FieldAddAttributes(builder, attributes):
-    return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
 
-def AddAttributes(builder, attributes):
+def AddAttributes(builder: flatbuffers.Builder, attributes: int):
-    return FieldAddAttributes(builder, attributes)
+    FieldAddAttributes(builder, attributes)
 
 def FieldStartAttributesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartAttributesVector(builder, numElems):
+def StartAttributesVector(builder, numElems: int) -> int:
     return FieldStartAttributesVector(builder, numElems)
 
 def FieldAddDocumentation(builder, documentation):
-    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
-def AddDocumentation(builder, documentation):
+def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
-    return FieldAddDocumentation(builder, documentation)
+    FieldAddDocumentation(builder, documentation)
 
 def FieldStartDocumentationVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartDocumentationVector(builder, numElems):
+def StartDocumentationVector(builder, numElems: int) -> int:
     return FieldStartDocumentationVector(builder, numElems)
 
 def FieldAddOptional(builder, optional):
-    return builder.PrependBoolSlot(11, optional, 0)
+    builder.PrependBoolSlot(11, optional, 0)
 
-def AddOptional(builder, optional):
+def AddOptional(builder: flatbuffers.Builder, optional: bool):
-    return FieldAddOptional(builder, optional)
+    FieldAddOptional(builder, optional)
 
 def FieldAddPadding(builder, padding):
-    return builder.PrependUint16Slot(12, padding, 0)
+    builder.PrependUint16Slot(12, padding, 0)
 
-def AddPadding(builder, padding):
+def AddPadding(builder: flatbuffers.Builder, padding: int):
-    return FieldAddPadding(builder, padding)
+    FieldAddPadding(builder, padding)
 
 def FieldEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/KeyValue.py

@@ -43,22 +43,22 @@ class KeyValue(object):
         return None
 
 def KeyValueStart(builder):
-    return builder.StartObject(2)
+    builder.StartObject(2)
 
 def Start(builder):
-    return KeyValueStart(builder)
+    KeyValueStart(builder)
 
 def KeyValueAddKey(builder, key):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
 
-def AddKey(builder, key):
+def AddKey(builder: flatbuffers.Builder, key: int):
-    return KeyValueAddKey(builder, key)
+    KeyValueAddKey(builder, key)
 
 def KeyValueAddValue(builder, value):
-    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
 
-def AddValue(builder, value):
+def AddValue(builder: flatbuffers.Builder, value: int):
-    return KeyValueAddValue(builder, value)
+    KeyValueAddValue(builder, value)
 
 def KeyValueEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/Object.py

@@ -42,7 +42,7 @@ class Object(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.Field import Field
+            from .reflection.Field import Field
             obj = Field()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -88,7 +88,7 @@ class Object(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.KeyValue import KeyValue
+            from .reflection.KeyValue import KeyValue
             obj = KeyValue()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -135,76 +135,76 @@ class Object(object):
         return None
 
 def ObjectStart(builder):
-    return builder.StartObject(8)
+    builder.StartObject(8)
 
 def Start(builder):
-    return ObjectStart(builder)
+    ObjectStart(builder)
 
 def ObjectAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return ObjectAddName(builder, name)
+    ObjectAddName(builder, name)
 
 def ObjectAddFields(builder, fields):
-    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(fields), 0)
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(fields), 0)
 
-def AddFields(builder, fields):
+def AddFields(builder: flatbuffers.Builder, fields: int):
-    return ObjectAddFields(builder, fields)
+    ObjectAddFields(builder, fields)
 
 def ObjectStartFieldsVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartFieldsVector(builder, numElems):
+def StartFieldsVector(builder, numElems: int) -> int:
     return ObjectStartFieldsVector(builder, numElems)
 
 def ObjectAddIsStruct(builder, isStruct):
-    return builder.PrependBoolSlot(2, isStruct, 0)
+    builder.PrependBoolSlot(2, isStruct, 0)
 
-def AddIsStruct(builder, isStruct):
+def AddIsStruct(builder: flatbuffers.Builder, isStruct: bool):
-    return ObjectAddIsStruct(builder, isStruct)
+    ObjectAddIsStruct(builder, isStruct)
 
 def ObjectAddMinalign(builder, minalign):
-    return builder.PrependInt32Slot(3, minalign, 0)
+    builder.PrependInt32Slot(3, minalign, 0)
 
-def AddMinalign(builder, minalign):
+def AddMinalign(builder: flatbuffers.Builder, minalign: int):
-    return ObjectAddMinalign(builder, minalign)
+    ObjectAddMinalign(builder, minalign)
 
 def ObjectAddBytesize(builder, bytesize):
-    return builder.PrependInt32Slot(4, bytesize, 0)
+    builder.PrependInt32Slot(4, bytesize, 0)
 
-def AddBytesize(builder, bytesize):
+def AddBytesize(builder: flatbuffers.Builder, bytesize: int):
-    return ObjectAddBytesize(builder, bytesize)
+    ObjectAddBytesize(builder, bytesize)
 
 def ObjectAddAttributes(builder, attributes):
-    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
 
-def AddAttributes(builder, attributes):
+def AddAttributes(builder: flatbuffers.Builder, attributes: int):
-    return ObjectAddAttributes(builder, attributes)
+    ObjectAddAttributes(builder, attributes)
 
 def ObjectStartAttributesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartAttributesVector(builder, numElems):
+def StartAttributesVector(builder, numElems: int) -> int:
     return ObjectStartAttributesVector(builder, numElems)
 
 def ObjectAddDocumentation(builder, documentation):
-    return builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
-def AddDocumentation(builder, documentation):
+def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
-    return ObjectAddDocumentation(builder, documentation)
+    ObjectAddDocumentation(builder, documentation)
 
 def ObjectStartDocumentationVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartDocumentationVector(builder, numElems):
+def StartDocumentationVector(builder, numElems: int) -> int:
     return ObjectStartDocumentationVector(builder, numElems)
 
 def ObjectAddDeclarationFile(builder, declarationFile):
-    return builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
 
-def AddDeclarationFile(builder, declarationFile):
+def AddDeclarationFile(builder: flatbuffers.Builder, declarationFile: int):
-    return ObjectAddDeclarationFile(builder, declarationFile)
+    ObjectAddDeclarationFile(builder, declarationFile)
 
 def ObjectEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/RPCCall.py

@@ -40,7 +40,7 @@ class RPCCall(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from reflection.Object import Object
+            from .reflection.Object import Object
             obj = Object()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -51,7 +51,7 @@ class RPCCall(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from reflection.Object import Object
+            from .reflection.Object import Object
             obj = Object()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -64,7 +64,7 @@ class RPCCall(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.KeyValue import KeyValue
+            from .reflection.KeyValue import KeyValue
             obj = KeyValue()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -103,51 +103,51 @@ class RPCCall(object):
         return o == 0
 
 def RPCCallStart(builder):
-    return builder.StartObject(5)
+    builder.StartObject(5)
 
 def Start(builder):
-    return RPCCallStart(builder)
+    RPCCallStart(builder)
 
 def RPCCallAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return RPCCallAddName(builder, name)
+    RPCCallAddName(builder, name)
 
 def RPCCallAddRequest(builder, request):
-    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(request), 0)
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(request), 0)
 
-def AddRequest(builder, request):
+def AddRequest(builder: flatbuffers.Builder, request: int):
-    return RPCCallAddRequest(builder, request)
+    RPCCallAddRequest(builder, request)
 
 def RPCCallAddResponse(builder, response):
-    return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(response), 0)
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(response), 0)
 
-def AddResponse(builder, response):
+def AddResponse(builder: flatbuffers.Builder, response: int):
-    return RPCCallAddResponse(builder, response)
+    RPCCallAddResponse(builder, response)
 
 def RPCCallAddAttributes(builder, attributes):
-    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
 
-def AddAttributes(builder, attributes):
+def AddAttributes(builder: flatbuffers.Builder, attributes: int):
-    return RPCCallAddAttributes(builder, attributes)
+    RPCCallAddAttributes(builder, attributes)
 
 def RPCCallStartAttributesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartAttributesVector(builder, numElems):
+def StartAttributesVector(builder, numElems: int) -> int:
     return RPCCallStartAttributesVector(builder, numElems)
 
 def RPCCallAddDocumentation(builder, documentation):
-    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
-def AddDocumentation(builder, documentation):
+def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
-    return RPCCallAddDocumentation(builder, documentation)
+    RPCCallAddDocumentation(builder, documentation)
 
 def RPCCallStartDocumentationVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartDocumentationVector(builder, numElems):
+def StartDocumentationVector(builder, numElems: int) -> int:
     return RPCCallStartDocumentationVector(builder, numElems)
 
 def RPCCallEnd(builder):

python/flatbuffers/reflection/Schema.py

@@ -35,7 +35,7 @@ class Schema(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.Object import Object
+            from .reflection.Object import Object
             obj = Object()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -60,7 +60,7 @@ class Schema(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.Enum import Enum
+            from .reflection.Enum import Enum
             obj = Enum()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -97,7 +97,7 @@ class Schema(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from reflection.Object import Object
+            from .reflection.Object import Object
             obj = Object()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -110,7 +110,7 @@ class Schema(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.Service import Service
+            from .reflection.Service import Service
             obj = Service()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -144,7 +144,7 @@ class Schema(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.SchemaFile import SchemaFile
+            from .reflection.SchemaFile import SchemaFile
             obj = SchemaFile()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -163,81 +163,81 @@ class Schema(object):
         return o == 0
 
 def SchemaStart(builder):
-    return builder.StartObject(8)
+    builder.StartObject(8)
 
 def Start(builder):
-    return SchemaStart(builder)
+    SchemaStart(builder)
 
 def SchemaAddObjects(builder, objects):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(objects), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(objects), 0)
 
-def AddObjects(builder, objects):
+def AddObjects(builder: flatbuffers.Builder, objects: int):
-    return SchemaAddObjects(builder, objects)
+    SchemaAddObjects(builder, objects)
 
 def SchemaStartObjectsVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartObjectsVector(builder, numElems):
+def StartObjectsVector(builder, numElems: int) -> int:
     return SchemaStartObjectsVector(builder, numElems)
 
 def SchemaAddEnums(builder, enums):
-    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)
 
-def AddEnums(builder, enums):
+def AddEnums(builder: flatbuffers.Builder, enums: int):
-    return SchemaAddEnums(builder, enums)
+    SchemaAddEnums(builder, enums)
 
 def SchemaStartEnumsVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartEnumsVector(builder, numElems):
+def StartEnumsVector(builder, numElems: int) -> int:
     return SchemaStartEnumsVector(builder, numElems)
 
 def SchemaAddFileIdent(builder, fileIdent):
-    return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)
 
-def AddFileIdent(builder, fileIdent):
+def AddFileIdent(builder: flatbuffers.Builder, fileIdent: int):
-    return SchemaAddFileIdent(builder, fileIdent)
+    SchemaAddFileIdent(builder, fileIdent)
 
 def SchemaAddFileExt(builder, fileExt):
-    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fileExt), 0)
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fileExt), 0)
 
-def AddFileExt(builder, fileExt):
+def AddFileExt(builder: flatbuffers.Builder, fileExt: int):
-    return SchemaAddFileExt(builder, fileExt)
+    SchemaAddFileExt(builder, fileExt)
 
 def SchemaAddRootTable(builder, rootTable):
-    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(rootTable), 0)
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(rootTable), 0)
 
-def AddRootTable(builder, rootTable):
+def AddRootTable(builder: flatbuffers.Builder, rootTable: int):
-    return SchemaAddRootTable(builder, rootTable)
+    SchemaAddRootTable(builder, rootTable)
 
 def SchemaAddServices(builder, services):
-    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(services), 0)
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(services), 0)
 
-def AddServices(builder, services):
+def AddServices(builder: flatbuffers.Builder, services: int):
-    return SchemaAddServices(builder, services)
+    SchemaAddServices(builder, services)
 
 def SchemaStartServicesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartServicesVector(builder, numElems):
+def StartServicesVector(builder, numElems: int) -> int:
     return SchemaStartServicesVector(builder, numElems)
 
 def SchemaAddAdvancedFeatures(builder, advancedFeatures):
-    return builder.PrependUint64Slot(6, advancedFeatures, 0)
+    builder.PrependUint64Slot(6, advancedFeatures, 0)
 
-def AddAdvancedFeatures(builder, advancedFeatures):
+def AddAdvancedFeatures(builder: flatbuffers.Builder, advancedFeatures: int):
-    return SchemaAddAdvancedFeatures(builder, advancedFeatures)
+    SchemaAddAdvancedFeatures(builder, advancedFeatures)
 
 def SchemaAddFbsFiles(builder, fbsFiles):
-    return builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(fbsFiles), 0)
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(fbsFiles), 0)
 
-def AddFbsFiles(builder, fbsFiles):
+def AddFbsFiles(builder: flatbuffers.Builder, fbsFiles: int):
-    return SchemaAddFbsFiles(builder, fbsFiles)
+    SchemaAddFbsFiles(builder, fbsFiles)
 
 def SchemaStartFbsFilesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartFbsFilesVector(builder, numElems):
+def StartFbsFilesVector(builder, numElems: int) -> int:
     return SchemaStartFbsFilesVector(builder, numElems)
 
 def SchemaEnd(builder):

python/flatbuffers/reflection/SchemaFile.py

@@ -61,27 +61,27 @@ class SchemaFile(object):
         return o == 0
 
 def SchemaFileStart(builder):
-    return builder.StartObject(2)
+    builder.StartObject(2)
 
 def Start(builder):
-    return SchemaFileStart(builder)
+    SchemaFileStart(builder)
 
 def SchemaFileAddFilename(builder, filename):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(filename), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(filename), 0)
 
-def AddFilename(builder, filename):
+def AddFilename(builder: flatbuffers.Builder, filename: int):
-    return SchemaFileAddFilename(builder, filename)
+    SchemaFileAddFilename(builder, filename)
 
 def SchemaFileAddIncludedFilenames(builder, includedFilenames):
-    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(includedFilenames), 0)
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(includedFilenames), 0)
 
-def AddIncludedFilenames(builder, includedFilenames):
+def AddIncludedFilenames(builder: flatbuffers.Builder, includedFilenames: int):
-    return SchemaFileAddIncludedFilenames(builder, includedFilenames)
+    SchemaFileAddIncludedFilenames(builder, includedFilenames)
 
 def SchemaFileStartIncludedFilenamesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartIncludedFilenamesVector(builder, numElems):
+def StartIncludedFilenamesVector(builder, numElems: int) -> int:
     return SchemaFileStartIncludedFilenamesVector(builder, numElems)
 
 def SchemaFileEnd(builder):

python/flatbuffers/reflection/Service.py

@@ -42,7 +42,7 @@ class Service(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.RPCCall import RPCCall
+            from .reflection.RPCCall import RPCCall
             obj = RPCCall()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -67,7 +67,7 @@ class Service(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from reflection.KeyValue import KeyValue
+            from .reflection.KeyValue import KeyValue
             obj = KeyValue()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -114,58 +114,58 @@ class Service(object):
         return None
 
 def ServiceStart(builder):
-    return builder.StartObject(5)
+    builder.StartObject(5)
 
 def Start(builder):
-    return ServiceStart(builder)
+    ServiceStart(builder)
 
 def ServiceAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return ServiceAddName(builder, name)
+    ServiceAddName(builder, name)
 
 def ServiceAddCalls(builder, calls):
-    return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(calls), 0)
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(calls), 0)
 
-def AddCalls(builder, calls):
+def AddCalls(builder: flatbuffers.Builder, calls: int):
-    return ServiceAddCalls(builder, calls)
+    ServiceAddCalls(builder, calls)
 
 def ServiceStartCallsVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartCallsVector(builder, numElems):
+def StartCallsVector(builder, numElems: int) -> int:
     return ServiceStartCallsVector(builder, numElems)
 
 def ServiceAddAttributes(builder, attributes):
-    return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
 
-def AddAttributes(builder, attributes):
+def AddAttributes(builder: flatbuffers.Builder, attributes: int):
-    return ServiceAddAttributes(builder, attributes)
+    ServiceAddAttributes(builder, attributes)
 
 def ServiceStartAttributesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartAttributesVector(builder, numElems):
+def StartAttributesVector(builder, numElems: int) -> int:
     return ServiceStartAttributesVector(builder, numElems)
 
 def ServiceAddDocumentation(builder, documentation):
-    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
-def AddDocumentation(builder, documentation):
+def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
-    return ServiceAddDocumentation(builder, documentation)
+    ServiceAddDocumentation(builder, documentation)
 
 def ServiceStartDocumentationVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartDocumentationVector(builder, numElems):
+def StartDocumentationVector(builder, numElems: int) -> int:
     return ServiceStartDocumentationVector(builder, numElems)
 
 def ServiceAddDeclarationFile(builder, declarationFile):
-    return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
 
-def AddDeclarationFile(builder, declarationFile):
+def AddDeclarationFile(builder: flatbuffers.Builder, declarationFile: int):
-    return ServiceAddDeclarationFile(builder, declarationFile)
+    ServiceAddDeclarationFile(builder, declarationFile)
 
 def ServiceEnd(builder):
     return builder.EndObject()

python/flatbuffers/reflection/Type.py

@@ -73,46 +73,46 @@ class Type(object):
         return 0
 
 def TypeStart(builder):
-    return builder.StartObject(6)
+    builder.StartObject(6)
 
 def Start(builder):
-    return TypeStart(builder)
+    TypeStart(builder)
 
 def TypeAddBaseType(builder, baseType):
-    return builder.PrependInt8Slot(0, baseType, 0)
+    builder.PrependInt8Slot(0, baseType, 0)
 
-def AddBaseType(builder, baseType):
+def AddBaseType(builder: flatbuffers.Builder, baseType: int):
-    return TypeAddBaseType(builder, baseType)
+    TypeAddBaseType(builder, baseType)
 
 def TypeAddElement(builder, element):
-    return builder.PrependInt8Slot(1, element, 0)
+    builder.PrependInt8Slot(1, element, 0)
 
-def AddElement(builder, element):
+def AddElement(builder: flatbuffers.Builder, element: int):
-    return TypeAddElement(builder, element)
+    TypeAddElement(builder, element)
 
 def TypeAddIndex(builder, index):
-    return builder.PrependInt32Slot(2, index, -1)
+    builder.PrependInt32Slot(2, index, -1)
 
-def AddIndex(builder, index):
+def AddIndex(builder: flatbuffers.Builder, index: int):
-    return TypeAddIndex(builder, index)
+    TypeAddIndex(builder, index)
 
 def TypeAddFixedLength(builder, fixedLength):
-    return builder.PrependUint16Slot(3, fixedLength, 0)
+    builder.PrependUint16Slot(3, fixedLength, 0)
 
-def AddFixedLength(builder, fixedLength):
+def AddFixedLength(builder: flatbuffers.Builder, fixedLength: int):
-    return TypeAddFixedLength(builder, fixedLength)
+    TypeAddFixedLength(builder, fixedLength)
 
 def TypeAddBaseSize(builder, baseSize):
-    return builder.PrependUint32Slot(4, baseSize, 4)
+    builder.PrependUint32Slot(4, baseSize, 4)
 
-def AddBaseSize(builder, baseSize):
+def AddBaseSize(builder: flatbuffers.Builder, baseSize: int):
-    return TypeAddBaseSize(builder, baseSize)
+    TypeAddBaseSize(builder, baseSize)
 
 def TypeAddElementSize(builder, elementSize):
-    return builder.PrependUint32Slot(5, elementSize, 0)
+    builder.PrependUint32Slot(5, elementSize, 0)
 
-def AddElementSize(builder, elementSize):
+def AddElementSize(builder: flatbuffers.Builder, elementSize: int):
-    return TypeAddElementSize(builder, elementSize)
+    TypeAddElementSize(builder, elementSize)
 
 def TypeEnd(builder):
     return builder.EndObject()

scripts/generate_code.py

@@ -103,7 +103,7 @@ JAVA_OPTS = ["--java"]
 KOTLIN_OPTS = ["--kotlin"]
 PHP_OPTS = ["--php"]
 DART_OPTS = ["--dart"]
-PYTHON_OPTS = ["--python"]
+PYTHON_OPTS = ["--python", "--python-typing"]
 BINARY_OPTS = ["-b", "--schema", "--bfbs-comments", "--bfbs-builtins"]
 PROTO_OPTS = ["--proto"]
 

src/flatc.cpp

@@ -252,6 +252,8 @@ const static FlatCOption flatc_options[] = {
     "Currently this is required to generate private types in Rust" },
   { "", "python-no-type-prefix-suffix", "",
     "Skip emission of Python functions that are prefixed with typenames" },
+  { "", "python-typing", "",
+    "Generate Python type annotations" },
   { "", "file-names-only", "",
     "Print out generated file names without writing to the files"},
 };
@@ -652,9 +654,11 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc,
         opts.ts_no_import_ext = true;
       } else if (arg == "--no-leak-private-annotation") {
         opts.no_leak_private_annotations = true;
-       } else if (arg == "--python-no-type-prefix-suffix") {
+      } else if (arg == "--python-no-type-prefix-suffix") {
         opts.python_no_type_prefix_suffix = true;
-     } else if (arg == "--annotate-sparse-vectors") {
+      } else if (arg == "--python-typing") {
+        opts.python_typing = true;
+      } else if (arg == "--annotate-sparse-vectors") {
         options.annotate_include_vector_contents = false;
       } else if (arg == "--annotate") {
         if (++argi >= argc) Error("missing path following: " + arg, true);

src/idl_gen_python.cpp

@@ -35,6 +35,9 @@ namespace python {
 
 namespace {
 
+typedef std::pair<std::string, std::string> ImportMapEntry;
+typedef std::set<ImportMapEntry> ImportMap;
+
 static std::set<std::string> PythonKeywords() {
   return { "False", "None",   "True",     "and",   "as",     "assert",
            "break", "class",  "continue", "def",   "del",    "elif",
@@ -129,7 +132,11 @@ class PythonGenerator : public BaseGenerator {
 
     code += Indent + "@classmethod\n";
     code += Indent + "def GetRootAs";
-    code += "(cls, buf, offset=0):";
+    if (parser_.opts.python_typing) {
+      code += "(cls, buf, offset: int = 0):";
+    } else {
+      code += "(cls, buf, offset=0):";
+    }
     code += "\n";
     code += Indent + Indent;
     code += "n = flatbuffers.encode.Get";
@@ -156,7 +163,11 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
 
     GenReceiver(struct_def, code_ptr);
-    code += "Init(self, buf, pos):\n";
+    if (parser_.opts.python_typing) {
+      code += "Init(self, buf: bytes, pos: int):\n";
+    } else {
+      code += "Init(self, buf, pos):\n";
+    }
     code += Indent + Indent + "self._tab = flatbuffers.table.Table(buf, pos)\n";
     code += "\n";
   }
@@ -167,8 +178,11 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
 
     GenReceiver(struct_def, code_ptr);
-    code += namer_.Method(field) + "Length(self";
+    code += namer_.Method(field) + "Length(self)";
-    code += "):";
+    if (parser_.opts.python_typing) {
+      code += " -> int";
+    }
+    code += ":";
     if(!IsArray(field.value.type)){
       code += OffsetPrefix(field,false);
       code += GenIndents(3) + "return self._tab.VectorLen(o)";
@@ -184,8 +198,11 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
 
     GenReceiver(struct_def, code_ptr);
-    code += namer_.Method(field) + "IsNone(self";
+    code += namer_.Method(field) + "IsNone(self)";
-    code += "):";
+    if (parser_.opts.python_typing) {
+      code += " -> bool";
+    }
+    code += ":";
     if(!IsArray(field.value.type)){
       code += GenIndents(2) +
               "o = flatbuffers.number_types.UOffsetTFlags.py_type" +
@@ -253,17 +270,32 @@ class PythonGenerator : public BaseGenerator {
 
   // Get the value of a fixed size array.
   void GetArrayOfStruct(const StructDef &struct_def, const FieldDef &field,
-                        std::string *code_ptr) const {
+                        std::string *code_ptr, ImportMap &imports) const {
     auto &code = *code_ptr;
     const auto vec_type = field.value.type.VectorType();
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
-    code += "(self, i: int):";
+
-    if (parser_.opts.include_dependence_headers) {
+    const ImportMapEntry import_entry = {
-      code += GenIndents(2);
+      "." + GenPackageReference(field.value.type), TypeName(field)
-      code += "from " + GenPackageReference(field.value.type) + " import " +
+    };
-              TypeName(field);
+
+    if (parser_.opts.python_typing) {
+      const std::string return_type = ReturnType(struct_def, field);
+      code += "(self, i: int)";
+      code += " -> " + return_type + ":";
+
+      imports.insert(import_entry);
+    } else {
+      code += "(self, i):";
     }
+
+    if (parser_.opts.include_dependence_headers && !parser_.opts.python_typing) {
+      code += GenIndents(2);
+      code += "from " + import_entry.first + " import " + import_entry.second +
+              "\n";
+    }
+
     code += GenIndents(2) + "obj = " + TypeName(field) + "()";
     code += GenIndents(2) + "obj.Init(self._tab.Bytes, self._tab.Pos + ";
     code += NumToString(field.value.offset) + " + i * ";
@@ -299,11 +331,22 @@ class PythonGenerator : public BaseGenerator {
   // Get a struct by initializing an existing struct.
   // Specific to Table.
   void GetStructFieldOfTable(const StructDef &struct_def, const FieldDef &field,
-                             std::string *code_ptr) const {
+                             std::string *code_ptr, ImportMap &imports) const {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += namer_.Method(field);
+    code += namer_.Method(field) + "(self)";
-    code += "(self):";
+
+    const ImportMapEntry import_entry = {
+      "." + GenPackageReference(field.value.type), TypeName(field)
+    };
+
+    if (parser_.opts.python_typing) {
+      const std::string return_type = ReturnType(struct_def, field);
+      code += " -> Optional[" + return_type + "]";
+      imports.insert(ImportMapEntry{ "typing", "Optional" });
+      imports.insert(import_entry);
+    }
+    code += ":";
     code += OffsetPrefix(field);
     if (field.value.type.struct_def->fixed) {
       code += Indent + Indent + Indent + "x = o + self._tab.Pos\n";
@@ -311,10 +354,11 @@ class PythonGenerator : public BaseGenerator {
       code += Indent + Indent + Indent;
       code += "x = self._tab.Indirect(o + self._tab.Pos)\n";
     }
-    if (parser_.opts.include_dependence_headers) {
+
+    if (parser_.opts.include_dependence_headers && !parser_.opts.python_typing) {
       code += Indent + Indent + Indent;
-      code += "from " + GenPackageReference(field.value.type) + " import " +
+      code += "from " + import_entry.first + " import " + import_entry.second +
-              TypeName(field) + "\n";
+              "\n";
     }
     code += Indent + Indent + Indent + "obj = " + TypeName(field) + "()\n";
     code += Indent + Indent + Indent + "obj.Init(self._tab.Bytes, x)\n";
@@ -324,11 +368,18 @@ class PythonGenerator : public BaseGenerator {
 
   // Get the value of a string.
   void GetStringField(const StructDef &struct_def, const FieldDef &field,
-                      std::string *code_ptr) const {
+                      std::string *code_ptr, ImportMap &imports) const {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
-    code += "(self):";
+
+    if (parser_.opts.python_typing) {
+      code += "(self) -> Optional[str]:";
+      imports.insert(ImportMapEntry{ "typing", "Optional" });
+    } else {
+      code += "(self):";
+    }
+
     code += OffsetPrefix(field);
     code += Indent + Indent + Indent + "return " + GenGetter(field.value.type);
     code += "o + self._tab.Pos)\n";
@@ -337,21 +388,34 @@ class PythonGenerator : public BaseGenerator {
 
   // Get the value of a union from an object.
   void GetUnionField(const StructDef &struct_def, const FieldDef &field,
-                     std::string *code_ptr) const {
+                     std::string *code_ptr, ImportMap &imports) const {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += namer_.Method(field) + "(self):";
+    std::string return_ty = "flatbuffers.table.Table";
+
+    bool is_native_table = TypeName(field) == "*flatbuffers.Table";
+    ImportMapEntry import_entry;
+    if (is_native_table) {
+      import_entry = ImportMapEntry{ "flatbuffers.table", "Table" };
+    } else {
+      return_ty = TypeName(field);
+      import_entry = ImportMapEntry{ GenPackageReference(field.value.type),
+                                     TypeName(field) };
+    }
+
+    code += namer_.Method(field) + "(self)";
+    if (parser_.opts.python_typing) {
+      code += " -> Optional[" + return_ty + "]";
+      imports.insert(ImportMapEntry{ "typing", "Optional" });
+      imports.insert(import_entry);
+    }
+    code += ":";
     code += OffsetPrefix(field);
 
-    // TODO(rw): this works and is not the good way to it:
+    if (!parser_.opts.python_typing) {
-    bool is_native_table = TypeName(field) == "*flatbuffers.Table";
-    if (is_native_table) {
-      code +=
-          Indent + Indent + Indent + "from flatbuffers.table import Table\n";
-    } else if (parser_.opts.include_dependence_headers) {
       code += Indent + Indent + Indent;
-      code += "from " + GenPackageReference(field.value.type) + " import " +
+      code += "from " + import_entry.first + " import " + import_entry.second +
-              TypeName(field) + "\n";
+              "\n";
     }
     code += Indent + Indent + Indent + "obj = Table(bytearray(), 0)\n";
     code += Indent + Indent + Indent + GenGetter(field.value.type);
@@ -373,14 +437,26 @@ class PythonGenerator : public BaseGenerator {
 
   // Get the value of a vector's struct member.
   void GetMemberOfVectorOfStruct(const StructDef &struct_def,
-                                 const FieldDef &field,
+                                 const FieldDef &field, std::string *code_ptr,
-                                 std::string *code_ptr) const {
+                                 ImportMap &imports) const {
     auto &code = *code_ptr;
     auto vectortype = field.value.type.VectorType();
 
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
-    code += "(self, j):" + OffsetPrefix(field);
+    const ImportMapEntry import_entry = {
+      "." + GenPackageReference(field.value.type), TypeName(field)
+    };
+
+    if (parser_.opts.python_typing) {
+      const std::string return_type = ReturnType(struct_def, field);
+      code += "(self, j: int) -> Optional[" + return_type + "]";
+      imports.insert(ImportMapEntry{ "typing", "Optional" });
+      imports.insert(import_entry);
+    } else {
+      code += "(self, j)";
+    }
+    code += ":" + OffsetPrefix(field);
     code += Indent + Indent + Indent + "x = self._tab.Vector(o)\n";
     code += Indent + Indent + Indent;
     code += "x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * ";
@@ -388,10 +464,10 @@ class PythonGenerator : public BaseGenerator {
     if (!(vectortype.struct_def->fixed)) {
       code += Indent + Indent + Indent + "x = self._tab.Indirect(x)\n";
     }
-    if (parser_.opts.include_dependence_headers) {
+    if (parser_.opts.include_dependence_headers && !parser_.opts.python_typing) {
       code += Indent + Indent + Indent;
-      code += "from " + GenPackageReference(field.value.type) + " import " +
+      code += "from " + import_entry.first + " import " + import_entry.second +
-              TypeName(field) + "\n";
+              "\n";
     }
     code += Indent + Indent + Indent + "obj = " + TypeName(field) + "()\n";
     code += Indent + Indent + Indent + "obj.Init(self._tab.Bytes, x)\n";
@@ -409,7 +485,12 @@ class PythonGenerator : public BaseGenerator {
 
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
-    code += "(self, j):";
+    if (parser_.opts.python_typing) {
+      code += "(self, j: int)";
+    } else {
+      code += "(self, j)";
+    }
+    code += ":";
     code += OffsetPrefix(field);
     code += Indent + Indent + Indent + "a = self._tab.Vector(o)\n";
     code += Indent + Indent + Indent;
@@ -476,8 +557,8 @@ class PythonGenerator : public BaseGenerator {
 
   // Returns a nested flatbuffer as itself.
   void GetVectorAsNestedFlatbuffer(const StructDef &struct_def,
-                                   const FieldDef &field,
+                                   const FieldDef &field, std::string *code_ptr,
-                                   std::string *code_ptr) const {
+                                   ImportMap &imports) const {
     auto nested = field.attributes.Lookup("nested_flatbuffer");
     if (!nested) { return; }  // There is no nested flatbuffer.
 
@@ -487,14 +568,26 @@ class PythonGenerator : public BaseGenerator {
       qualified_name = nested->constant;
     }
 
+    const ImportMapEntry import_entry = { "." + qualified_name,
+                                          unqualified_name };
+
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
-    code += namer_.Method(field) + "NestedRoot(self):";
+    code += namer_.Method(field) + "NestedRoot(self)";
+    if (parser_.opts.python_typing) {
+      code += " -> Union[" + unqualified_name + ", int]";
+      imports.insert(ImportMapEntry{ "typing", "Union" });
+      imports.insert(import_entry);
+    }
+    code += ":";
 
     code += OffsetPrefix(field);
 
-    code += Indent + Indent + Indent;
+    if (!parser_.opts.python_typing) {
-    code += "from " + qualified_name + " import " + unqualified_name + "\n";
+      code += Indent + Indent + Indent;
+      code += "from " + import_entry.first + " import " + import_entry.second +
+              "\n";
+    }
     code += Indent + Indent + Indent + "return " + unqualified_name;
     code += ".GetRootAs";
     code += "(self._tab.Bytes, self._tab.Vector(o))\n";
@@ -613,15 +706,25 @@ class PythonGenerator : public BaseGenerator {
 
     const auto name = parser_.opts.python_no_type_prefix_suffix ? "Start" : struct_type + "Start";
 
-    code += "def " + name + "(builder):\n";
+    code += "def " + name;
-    code += Indent + "return builder.StartObject(";
+    if (parser_.opts.python_typing) {
+      code += "(builder: flatbuffers.Builder):\n";
+    } else {
+      code += "(builder):\n";
+    }
+
+    code += Indent + "builder.StartObject(";
     code += NumToString(struct_def.fields.vec.size());
     code += ")\n\n";
 
     if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
       // Generate method without struct name.
-      code += "def Start(builder):\n";
+      if (parser_.opts.python_typing) {
-      code += Indent + "return " + struct_type + "Start(builder)\n\n";
+        code += "def Start(builder: flatbuffers.Builder):\n";
+      } else {
+        code += "def Start(builder):\n";
+      }
+      code += Indent + struct_type + "Start(builder)\n\n";
     }
   }
 
@@ -631,15 +734,19 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
     const std::string field_var = namer_.Variable(field);
     const std::string field_method = namer_.Method(field);
+    const std::string field_ty = GenFieldTy(field);
 
     const auto name = parser_.opts.python_no_type_prefix_suffix ? "Add" + field_method : namer_.Type(struct_def) + "Add" + field_method;
 
     // Generate method with struct name.
     code += "def " + name;
-    code += "(builder, ";
+    if (parser_.opts.python_typing) {
-    code += field_var;
+      code += "(builder: flatbuffers.Builder, " + field_var + ": " + field_ty; 
+    } else {
+      code += "(builder, " + field_var;
+    }
     code += "):\n";
-    code += Indent + "return builder.Prepend";
+    code += Indent + "builder.Prepend";
     code += GenMethod(field) + "Slot(";
     code += NumToString(offset) + ", ";
     if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) {
@@ -660,9 +767,9 @@ class PythonGenerator : public BaseGenerator {
 
     if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
       // Generate method without struct name.
-      code += "def Add" + field_method + "(builder, " + field_var + "):\n";
+      code += "def Add" + field_method + "(builder: flatbuffers.Builder, " + field_var + ": " + field_ty + "):\n";
       code +=
-          Indent + "return " + namer_.Type(struct_def) + "Add" + field_method;
+          Indent + namer_.Type(struct_def) + "Add" + field_method;
       code += "(builder, ";
       code += field_var;
       code += ")\n\n";
@@ -679,7 +786,12 @@ class PythonGenerator : public BaseGenerator {
     // Generate method with struct name.
     const auto name = parser_.opts.python_no_type_prefix_suffix ? "Start" + field_method : struct_type + "Start" + field_method;
     code += "def " + name;
-    code += "Vector(builder, numElems):\n";
+    if (parser_.opts.python_typing) {
+      code += "Vector(builder, numElems: int) -> int:\n";
+    } else {
+      code += "Vector(builder, numElems):\n";
+    }
+
     code += Indent + "return builder.StartVector(";
     auto vector_type = field.value.type.VectorType();
     auto alignment = InlineAlignment(vector_type);
@@ -690,7 +802,7 @@ class PythonGenerator : public BaseGenerator {
 
     if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
       // Generate method without struct name.
-      code += "def Start" + field_method + "Vector(builder, numElems):\n";
+      code += "def Start" + field_method + "Vector(builder, numElems: int) -> int:\n";
       code += Indent + "return " + struct_type + "Start";
       code += field_method + "Vector(builder, numElems)\n\n";
     }
@@ -739,12 +851,20 @@ class PythonGenerator : public BaseGenerator {
 
     const auto name = parser_.opts.python_no_type_prefix_suffix ? "End" : namer_.Type(struct_def) + "End";
     // Generate method with struct name.
-    code += "def " + name + "(builder):\n";
+    if (parser_.opts.python_typing) {
+      code += "def " + name + "(builder: flatbuffers.Builder) -> int:\n";
+    } else {
+      code += "def " + name + "(builder):\n";
+    }
     code += Indent + "return builder.EndObject()\n\n";
 
     if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
       // Generate method without struct name.
-      code += "def End(builder):\n";
+      if (parser_.opts.python_typing) {
+        code += "def End(builder: flatbuffers.Builder) -> int:\n";
+      } else {
+        code += "def End(builder):\n";
+      }
       code += Indent + "return " + namer_.Type(struct_def) + "End(builder)";
       code += "\n";
     }
@@ -759,7 +879,7 @@ class PythonGenerator : public BaseGenerator {
 
   // Generate a struct field, conditioned on its child type(s).
   void GenStructAccessor(const StructDef &struct_def, const FieldDef &field,
-                         std::string *code_ptr) const {
+                         std::string *code_ptr, ImportMap &imports) const {
     GenComment(field.doc_comment, code_ptr, &def_comment, Indent.c_str());
     if (IsScalar(field.value.type.base_type)) {
       if (struct_def.fixed) {
@@ -773,35 +893,35 @@ class PythonGenerator : public BaseGenerator {
           if (struct_def.fixed) {
             GetStructFieldOfStruct(struct_def, field, code_ptr);
           } else {
-            GetStructFieldOfTable(struct_def, field, code_ptr);
+            GetStructFieldOfTable(struct_def, field, code_ptr, imports);
           }
           break;
         case BASE_TYPE_STRING:
-          GetStringField(struct_def, field, code_ptr);
+          GetStringField(struct_def, field, code_ptr, imports);
           break;
         case BASE_TYPE_VECTOR: {
           auto vectortype = field.value.type.VectorType();
           if (vectortype.base_type == BASE_TYPE_STRUCT) {
-            GetMemberOfVectorOfStruct(struct_def, field, code_ptr);
+            GetMemberOfVectorOfStruct(struct_def, field, code_ptr, imports);
           } else {
             GetMemberOfVectorOfNonStruct(struct_def, field, code_ptr);
             GetVectorOfNonStructAsNumpy(struct_def, field, code_ptr);
-            GetVectorAsNestedFlatbuffer(struct_def, field, code_ptr);
+            GetVectorAsNestedFlatbuffer(struct_def, field, code_ptr, imports);
           }
           break;
         }
         case BASE_TYPE_ARRAY: {
           auto vectortype = field.value.type.VectorType();
           if (vectortype.base_type == BASE_TYPE_STRUCT) {
-            GetArrayOfStruct(struct_def, field, code_ptr);
+            GetArrayOfStruct(struct_def, field, code_ptr, imports);
           } else {
             GetArrayOfNonStruct(struct_def, field, code_ptr);
             GetVectorOfNonStructAsNumpy(struct_def, field, code_ptr);
-            GetVectorAsNestedFlatbuffer(struct_def, field, code_ptr);
+            GetVectorAsNestedFlatbuffer(struct_def, field, code_ptr, imports);
           }
           break;
         }
-        case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break;
+        case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr, imports); break;
         default: FLATBUFFERS_ASSERT(0);
       }
     }
@@ -816,7 +936,11 @@ class PythonGenerator : public BaseGenerator {
                        std::string *code_ptr) const {
     auto &code = *code_ptr;
     code += Indent + "@classmethod\n";
-    code += Indent + "def SizeOf(cls):\n";
+    if (parser_.opts.python_typing) {
+      code += Indent + "def SizeOf(cls) -> int:\n";
+    } else {
+      code += Indent + "def SizeOf(cls):\n";
+    }
     code +=
         Indent + Indent + "return " + NumToString(struct_def.bytesize) + "\n";
     code += "\n";
@@ -868,7 +992,8 @@ class PythonGenerator : public BaseGenerator {
   }
 
   // Generates struct or table methods.
-  void GenStruct(const StructDef &struct_def, std::string *code_ptr) const {
+  void GenStruct(const StructDef &struct_def, std::string *code_ptr,
+                 ImportMap &imports) const {
     if (struct_def.generated) return;
 
     GenComment(struct_def.doc_comment, code_ptr, &def_comment);
@@ -893,7 +1018,7 @@ class PythonGenerator : public BaseGenerator {
       auto &field = **it;
       if (field.deprecated) continue;
 
-      GenStructAccessor(struct_def, field, code_ptr);
+      GenStructAccessor(struct_def, field, code_ptr, imports);
     }
 
     if (struct_def.fixed) {
@@ -1763,6 +1888,31 @@ class PythonGenerator : public BaseGenerator {
     }
   }
 
+  std::string GenFieldTy(const FieldDef &field) const {
+    if (IsScalar(field.value.type.base_type) || IsArray(field.value.type)) {
+      const std::string ty = GenTypeBasic(field.value.type);
+      if (ty.find("int") != std::string::npos) {
+        return "int";
+      }
+
+      if (ty.find("float") != std::string::npos) {
+        return "float";
+      }
+
+      if (ty == "bool") {
+        return "bool";
+      }
+
+      return "Any";
+    } else {
+      if (IsStruct(field.value.type)) {
+        return "Any";
+      } else {
+        return "int";
+      }
+    }
+  }
+
   // Returns the method name for use with add/put calls.
   std::string GenMethod(const FieldDef &field) const {
     return (IsScalar(field.value.type.base_type) || IsArray(field.value.type))
@@ -1805,6 +1955,31 @@ class PythonGenerator : public BaseGenerator {
     return GenTypeGet(field.value.type);
   }
 
+  std::string ReturnType(const StructDef &struct_def,
+                         const FieldDef &field) const {
+    // If we have a class member that returns an instance of the same class,
+    // for example:
+    // class Field(object):
+    //   def Children(self, j: int) -> Optional[Field]:
+    //     pass
+    //
+    // we need to quote the return type:
+    // class Field(object):
+    //   def Children(self, j: int) -> Optional['Field']:
+    //     pass
+    //
+    // because Python is unable to resolve the name during parse and will return
+    // an error.
+    // (see PEP 484 under forward references:
+    // https://peps.python.org/pep-0484/#forward-references)
+    const std::string self_type = struct_def.name;
+    std::string field_type = TypeName(field);
+
+    if (self_type == field_type) { field_type = "'" + field_type + "'"; }
+
+    return field_type;
+  }
+
   // Create a struct with a builder and the struct's arguments.
   void GenStructBuilder(const StructDef &struct_def,
                         std::string *code_ptr) const {
@@ -1822,13 +1997,16 @@ class PythonGenerator : public BaseGenerator {
 
   bool generate() {
     std::string one_file_code;
+    ImportMap one_file_imports;
     if (!generateEnums(&one_file_code)) return false;
-    if (!generateStructs(&one_file_code)) return false;
+    if (!generateStructs(&one_file_code, one_file_imports)) return false;
 
     if (parser_.opts.one_file) {
+      const std::string mod = file_name_ + "_generated";
+
       // Legacy file format uses keep casing.
-      return SaveType(file_name_ + "_generated.py", *parser_.current_namespace_,
+      return SaveType(mod + ".py", *parser_.current_namespace_, one_file_code,
-                      one_file_code, true);
+                      one_file_imports, mod, true);
     }
 
     return true;
@@ -1848,29 +2026,45 @@ class PythonGenerator : public BaseGenerator {
       if (parser_.opts.one_file && !enumcode.empty()) {
         *one_file_code += enumcode + "\n\n";
       } else {
+        ImportMap imports;
+        const std::string mod =
+            namer_.File(enum_def, SkipFile::SuffixAndExtension);
+
         if (!SaveType(namer_.File(enum_def, SkipFile::Suffix),
-                      *enum_def.defined_namespace, enumcode, false))
+                      *enum_def.defined_namespace, enumcode, imports, mod,
+                      false))
           return false;
       }
     }
     return true;
   }
 
-  bool generateStructs(std::string *one_file_code) const {
+  bool generateStructs(std::string *one_file_code,
+                       ImportMap &one_file_imports) const {
     for (auto it = parser_.structs_.vec.begin();
          it != parser_.structs_.vec.end(); ++it) {
       auto &struct_def = **it;
       std::string declcode;
-      GenStruct(struct_def, &declcode);
+      ImportMap imports;
+      GenStruct(struct_def, &declcode, imports);
       if (parser_.opts.generate_object_based_api) {
         GenStructForObjectAPI(struct_def, &declcode);
       }
 
-      if (parser_.opts.one_file && !declcode.empty()) {
+      if (parser_.opts.one_file) {
-        *one_file_code += declcode + "\n\n";
+        if (!declcode.empty()) {
+          *one_file_code += declcode + "\n\n";
+        }
+
+        for (auto import_str: imports) {
+          one_file_imports.insert(import_str);
+        }
       } else {
+        const std::string mod =
+            namer_.File(struct_def, SkipFile::SuffixAndExtension);
         if (!SaveType(namer_.File(struct_def, SkipFile::Suffix),
-                      *struct_def.defined_namespace, declcode, true))
+                      *struct_def.defined_namespace, declcode, imports, mod,
+                      true))
           return false;
       }
     }
@@ -1879,24 +2073,44 @@ class PythonGenerator : public BaseGenerator {
 
   // Begin by declaring namespace and imports.
   void BeginFile(const std::string &name_space_name, const bool needs_imports,
-                 std::string *code_ptr) const {
+                 std::string *code_ptr, const std::string &mod,
+                 const ImportMap &imports) const {
     auto &code = *code_ptr;
     code = code + "# " + FlatBuffersGeneratedWarning() + "\n\n";
     code += "# namespace: " + name_space_name + "\n\n";
+
     if (needs_imports) {
+      const std::string local_import = "." + mod;
+
       code += "import flatbuffers\n";
       code += "from flatbuffers.compat import import_numpy\n";
+      if (parser_.opts.python_typing) {
+        code += "from typing import Any\n";
+
+        for (auto import_entry : imports) {
+          // If we have a file called, say, "MyType.py" and in it we have a
+          // class "MyType", we can generate imports -- usually when we
+          // have a type that contains arrays of itself -- of the type
+          // "from .MyType import MyType", which Python can't resolve. So
+          // if we are trying to import ourself, we skip.
+          if (import_entry.first != local_import) {
+            code += "from " + import_entry.first + " import " +
+                    import_entry.second + "\n";
+          }
+        }
+      }
       code += "np = import_numpy()\n\n";
     }
   }
 
   // Save out the generated code for a Python Table type.
   bool SaveType(const std::string &defname, const Namespace &ns,
-                const std::string &classcode, bool needs_imports) const {
+                const std::string &classcode, const ImportMap &imports,
+                const std::string &mod, bool needs_imports) const {
     if (!classcode.length()) return true;
 
     std::string code = "";
-    BeginFile(LastNamespacePart(ns), needs_imports, &code);
+    BeginFile(LastNamespacePart(ns), needs_imports, &code, mod, imports);
     code += classcode;
 
     const std::string directories =

tests/MyGame/Example/ArrayStruct.py

@@ -4,17 +4,19 @@
 
 import flatbuffers
 from flatbuffers.compat import import_numpy
+from typing import Any
+from .MyGame.Example.NestedStruct import NestedStruct
 np = import_numpy()
 
 class ArrayStruct(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def SizeOf(cls):
+    def SizeOf(cls) -> int:
         return 160
 
     # ArrayStruct
-    def Init(self, buf, pos):
+    def Init(self, buf: bytes, pos: int):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # ArrayStruct
@@ -33,28 +35,27 @@ class ArrayStruct(object):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 4, self.BLength())
 
     # ArrayStruct
-    def BLength(self):
+    def BLength(self) -> int:
         return 15
 
     # ArrayStruct
-    def BIsNone(self):
+    def BIsNone(self) -> bool:
         return False
 
     # ArrayStruct
     def C(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(64))
     # ArrayStruct
-    def D(self, i: int):
+    def D(self, i: int) -> NestedStruct:
-        from MyGame.Example.NestedStruct import NestedStruct
         obj = NestedStruct()
         obj.Init(self._tab.Bytes, self._tab.Pos + 72 + i * 32)
         return obj
 
     # ArrayStruct
-    def DLength(self):
+    def DLength(self) -> int:
         return 2
 
     # ArrayStruct
-    def DIsNone(self):
+    def DIsNone(self) -> bool:
         return False
 
     # ArrayStruct
@@ -73,11 +74,11 @@ class ArrayStruct(object):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 144, self.FLength())
 
     # ArrayStruct
-    def FLength(self):
+    def FLength(self) -> int:
         return 2
 
     # ArrayStruct
-    def FIsNone(self):
+    def FIsNone(self) -> bool:
         return False
 
 

tests/MyGame/Example/ArrayTable.py

@@ -4,13 +4,16 @@
 
 import flatbuffers
 from flatbuffers.compat import import_numpy
+from typing import Any
+from .MyGame.Example.ArrayStruct import ArrayStruct
+from typing import Optional
 np = import_numpy()
 
 class ArrayTable(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def GetRootAs(cls, buf, offset=0):
+    def GetRootAs(cls, buf, offset: int = 0):
         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
         x = ArrayTable()
         x.Init(buf, n + offset)
@@ -25,36 +28,35 @@ class ArrayTable(object):
         return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x41\x52\x52\x54", size_prefixed=size_prefixed)
 
     # ArrayTable
-    def Init(self, buf, pos):
+    def Init(self, buf: bytes, pos: int):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # ArrayTable
-    def A(self):
+    def A(self) -> Optional[ArrayStruct]:
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = o + self._tab.Pos
-            from MyGame.Example.ArrayStruct import ArrayStruct
             obj = ArrayStruct()
             obj.Init(self._tab.Bytes, x)
             return obj
         return None
 
-def ArrayTableStart(builder):
+def ArrayTableStart(builder: flatbuffers.Builder):
-    return builder.StartObject(1)
+    builder.StartObject(1)
 
-def Start(builder):
+def Start(builder: flatbuffers.Builder):
-    return ArrayTableStart(builder)
+    ArrayTableStart(builder)
 
-def ArrayTableAddA(builder, a):
+def ArrayTableAddA(builder: flatbuffers.Builder, a: Any):
-    return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
+    builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
 
-def AddA(builder, a):
+def AddA(builder: flatbuffers.Builder, a: Any):
-    return ArrayTableAddA(builder, a)
+    ArrayTableAddA(builder, a)
 
-def ArrayTableEnd(builder):
+def ArrayTableEnd(builder: flatbuffers.Builder) -> int:
     return builder.EndObject()
 
-def End(builder):
+def End(builder: flatbuffers.Builder) -> int:
     return ArrayTableEnd(builder)
 
 import MyGame.Example.ArrayStruct

tests/MyGame/Example/Monster.py

@@ -34,7 +34,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = o + self._tab.Pos
-            from MyGame.Example.Vec3 import Vec3
+            from .MyGame.Example.Vec3 import Vec3
             obj = Vec3()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -118,7 +118,7 @@ class Monster(object):
         if o != 0:
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
-            from MyGame.Example.Test import Test
+            from .MyGame.Example.Test import Test
             obj = Test()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -165,7 +165,7 @@ class Monster(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from MyGame.Example.Monster import Monster
+            from .MyGame.Example.Monster import Monster
             obj = Monster()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -188,7 +188,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from MyGame.Example.Monster import Monster
+            from .MyGame.Example.Monster import Monster
             obj = Monster()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -213,7 +213,7 @@ class Monster(object):
     def TestnestedflatbufferNestedRoot(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-            from MyGame.Example.Monster import Monster
+            from .MyGame.Example.Monster import Monster
             return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
@@ -234,7 +234,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from MyGame.Example.Stat import Stat
+            from .MyGame.Example.Stat import Stat
             obj = Stat()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -377,7 +377,7 @@ class Monster(object):
         if o != 0:
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
-            from MyGame.Example.Ability import Ability
+            from .MyGame.Example.Ability import Ability
             obj = Ability()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -428,7 +428,7 @@ class Monster(object):
         if o != 0:
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
-            from MyGame.Example.Test import Test
+            from .MyGame.Example.Test import Test
             obj = Test()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -505,7 +505,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from MyGame.InParentNamespace import InParentNamespace
+            from .MyGame.InParentNamespace import InParentNamespace
             obj = InParentNamespace()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -518,7 +518,7 @@ class Monster(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from MyGame.Example.Referrable import Referrable
+            from .MyGame.Example.Referrable import Referrable
             obj = Referrable()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -577,7 +577,7 @@ class Monster(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from MyGame.Example.Referrable import Referrable
+            from .MyGame.Example.Referrable import Referrable
             obj = Referrable()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -750,7 +750,7 @@ class Monster(object):
     def TestrequirednestedflatbufferNestedRoot(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
-            from MyGame.Example.Monster import Monster
+            from .MyGame.Example.Monster import Monster
             return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
@@ -773,7 +773,7 @@ class Monster(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from MyGame.Example.Stat import Stat
+            from .MyGame.Example.Stat import Stat
             obj = Stat()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -796,7 +796,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
         if o != 0:
             x = o + self._tab.Pos
-            from MyGame.Example.Test import Test
+            from .MyGame.Example.Test import Test
             obj = Test()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -873,117 +873,117 @@ class Monster(object):
         return float('inf')
 
 def MonsterStart(builder):
-    return builder.StartObject(62)
+    builder.StartObject(62)
 
 def Start(builder):
-    return MonsterStart(builder)
+    MonsterStart(builder)
 
 def MonsterAddPos(builder, pos):
-    return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
+    builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
 
-def AddPos(builder, pos):
+def AddPos(builder: flatbuffers.Builder, pos: Any):
-    return MonsterAddPos(builder, pos)
+    MonsterAddPos(builder, pos)
 
 def MonsterAddMana(builder, mana):
-    return builder.PrependInt16Slot(1, mana, 150)
+    builder.PrependInt16Slot(1, mana, 150)
 
-def AddMana(builder, mana):
+def AddMana(builder: flatbuffers.Builder, mana: int):
-    return MonsterAddMana(builder, mana)
+    MonsterAddMana(builder, mana)
 
 def MonsterAddHp(builder, hp):
-    return builder.PrependInt16Slot(2, hp, 100)
+    builder.PrependInt16Slot(2, hp, 100)
 
-def AddHp(builder, hp):
+def AddHp(builder: flatbuffers.Builder, hp: int):
-    return MonsterAddHp(builder, hp)
+    MonsterAddHp(builder, hp)
 
 def MonsterAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return MonsterAddName(builder, name)
+    MonsterAddName(builder, name)
 
 def MonsterAddInventory(builder, inventory):
-    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
 
-def AddInventory(builder, inventory):
+def AddInventory(builder: flatbuffers.Builder, inventory: int):
-    return MonsterAddInventory(builder, inventory)
+    MonsterAddInventory(builder, inventory)
 
 def MonsterStartInventoryVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartInventoryVector(builder, numElems):
+def StartInventoryVector(builder, numElems: int) -> int:
     return MonsterStartInventoryVector(builder, numElems)
 
 def MonsterAddColor(builder, color):
-    return builder.PrependUint8Slot(6, color, 8)
+    builder.PrependUint8Slot(6, color, 8)
 
-def AddColor(builder, color):
+def AddColor(builder: flatbuffers.Builder, color: int):
-    return MonsterAddColor(builder, color)
+    MonsterAddColor(builder, color)
 
 def MonsterAddTestType(builder, testType):
-    return builder.PrependUint8Slot(7, testType, 0)
+    builder.PrependUint8Slot(7, testType, 0)
 
-def AddTestType(builder, testType):
+def AddTestType(builder: flatbuffers.Builder, testType: int):
-    return MonsterAddTestType(builder, testType)
+    MonsterAddTestType(builder, testType)
 
 def MonsterAddTest(builder, test):
-    return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
 
-def AddTest(builder, test):
+def AddTest(builder: flatbuffers.Builder, test: int):
-    return MonsterAddTest(builder, test)
+    MonsterAddTest(builder, test)
 
 def MonsterAddTest4(builder, test4):
-    return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
 
-def AddTest4(builder, test4):
+def AddTest4(builder: flatbuffers.Builder, test4: int):
-    return MonsterAddTest4(builder, test4)
+    MonsterAddTest4(builder, test4)
 
 def MonsterStartTest4Vector(builder, numElems):
     return builder.StartVector(4, numElems, 2)
 
-def StartTest4Vector(builder, numElems):
+def StartTest4Vector(builder, numElems: int) -> int:
     return MonsterStartTest4Vector(builder, numElems)
 
 def MonsterAddTestarrayofstring(builder, testarrayofstring):
-    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
 
-def AddTestarrayofstring(builder, testarrayofstring):
+def AddTestarrayofstring(builder: flatbuffers.Builder, testarrayofstring: int):
-    return MonsterAddTestarrayofstring(builder, testarrayofstring)
+    MonsterAddTestarrayofstring(builder, testarrayofstring)
 
 def MonsterStartTestarrayofstringVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartTestarrayofstringVector(builder, numElems):
+def StartTestarrayofstringVector(builder, numElems: int) -> int:
     return MonsterStartTestarrayofstringVector(builder, numElems)
 
 def MonsterAddTestarrayoftables(builder, testarrayoftables):
-    return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
 
-def AddTestarrayoftables(builder, testarrayoftables):
+def AddTestarrayoftables(builder: flatbuffers.Builder, testarrayoftables: int):
-    return MonsterAddTestarrayoftables(builder, testarrayoftables)
+    MonsterAddTestarrayoftables(builder, testarrayoftables)
 
 def MonsterStartTestarrayoftablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartTestarrayoftablesVector(builder, numElems):
+def StartTestarrayoftablesVector(builder, numElems: int) -> int:
     return MonsterStartTestarrayoftablesVector(builder, numElems)
 
 def MonsterAddEnemy(builder, enemy):
-    return builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
+    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
 
-def AddEnemy(builder, enemy):
+def AddEnemy(builder: flatbuffers.Builder, enemy: int):
-    return MonsterAddEnemy(builder, enemy)
+    MonsterAddEnemy(builder, enemy)
 
 def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
-    return builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
+    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
 
-def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
+def AddTestnestedflatbuffer(builder: flatbuffers.Builder, testnestedflatbuffer: int):
-    return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
+    MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
 
 def MonsterStartTestnestedflatbufferVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartTestnestedflatbufferVector(builder, numElems):
+def StartTestnestedflatbufferVector(builder, numElems: int) -> int:
     return MonsterStartTestnestedflatbufferVector(builder, numElems)
 
 def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
@@ -994,303 +994,303 @@ def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
 def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes)
 def MonsterAddTestempty(builder, testempty):
-    return builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
+    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
 
-def AddTestempty(builder, testempty):
+def AddTestempty(builder: flatbuffers.Builder, testempty: int):
-    return MonsterAddTestempty(builder, testempty)
+    MonsterAddTestempty(builder, testempty)
 
 def MonsterAddTestbool(builder, testbool):
-    return builder.PrependBoolSlot(15, testbool, 0)
+    builder.PrependBoolSlot(15, testbool, 0)
 
-def AddTestbool(builder, testbool):
+def AddTestbool(builder: flatbuffers.Builder, testbool: bool):
-    return MonsterAddTestbool(builder, testbool)
+    MonsterAddTestbool(builder, testbool)
 
 def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
-    return builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
+    builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
 
-def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
+def AddTesthashs32Fnv1(builder: flatbuffers.Builder, testhashs32Fnv1: int):
-    return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
+    MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
 
 def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
-    return builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
+    builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
 
-def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
+def AddTesthashu32Fnv1(builder: flatbuffers.Builder, testhashu32Fnv1: int):
-    return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
+    MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
 
 def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
-    return builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
+    builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
 
-def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
+def AddTesthashs64Fnv1(builder: flatbuffers.Builder, testhashs64Fnv1: int):
-    return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
+    MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
 
 def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
-    return builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
+    builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
 
-def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
+def AddTesthashu64Fnv1(builder: flatbuffers.Builder, testhashu64Fnv1: int):
-    return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
+    MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
 
 def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
-    return builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
+    builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
 
-def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
+def AddTesthashs32Fnv1a(builder: flatbuffers.Builder, testhashs32Fnv1a: int):
-    return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
+    MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
 
 def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
-    return builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
+    builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
 
-def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
+def AddTesthashu32Fnv1a(builder: flatbuffers.Builder, testhashu32Fnv1a: int):
-    return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
+    MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
 
 def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
-    return builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
+    builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
 
-def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
+def AddTesthashs64Fnv1a(builder: flatbuffers.Builder, testhashs64Fnv1a: int):
-    return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
+    MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
 
 def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
-    return builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
+    builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
 
-def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
+def AddTesthashu64Fnv1a(builder: flatbuffers.Builder, testhashu64Fnv1a: int):
-    return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
+    MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
 
 def MonsterAddTestarrayofbools(builder, testarrayofbools):
-    return builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
+    builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
 
-def AddTestarrayofbools(builder, testarrayofbools):
+def AddTestarrayofbools(builder: flatbuffers.Builder, testarrayofbools: int):
-    return MonsterAddTestarrayofbools(builder, testarrayofbools)
+    MonsterAddTestarrayofbools(builder, testarrayofbools)
 
 def MonsterStartTestarrayofboolsVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartTestarrayofboolsVector(builder, numElems):
+def StartTestarrayofboolsVector(builder, numElems: int) -> int:
     return MonsterStartTestarrayofboolsVector(builder, numElems)
 
 def MonsterAddTestf(builder, testf):
-    return builder.PrependFloat32Slot(25, testf, 3.14159)
+    builder.PrependFloat32Slot(25, testf, 3.14159)
 
-def AddTestf(builder, testf):
+def AddTestf(builder: flatbuffers.Builder, testf: float):
-    return MonsterAddTestf(builder, testf)
+    MonsterAddTestf(builder, testf)
 
 def MonsterAddTestf2(builder, testf2):
-    return builder.PrependFloat32Slot(26, testf2, 3.0)
+    builder.PrependFloat32Slot(26, testf2, 3.0)
 
-def AddTestf2(builder, testf2):
+def AddTestf2(builder: flatbuffers.Builder, testf2: float):
-    return MonsterAddTestf2(builder, testf2)
+    MonsterAddTestf2(builder, testf2)
 
 def MonsterAddTestf3(builder, testf3):
-    return builder.PrependFloat32Slot(27, testf3, 0.0)
+    builder.PrependFloat32Slot(27, testf3, 0.0)
 
-def AddTestf3(builder, testf3):
+def AddTestf3(builder: flatbuffers.Builder, testf3: float):
-    return MonsterAddTestf3(builder, testf3)
+    MonsterAddTestf3(builder, testf3)
 
 def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
-    return builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
+    builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
 
-def AddTestarrayofstring2(builder, testarrayofstring2):
+def AddTestarrayofstring2(builder: flatbuffers.Builder, testarrayofstring2: int):
-    return MonsterAddTestarrayofstring2(builder, testarrayofstring2)
+    MonsterAddTestarrayofstring2(builder, testarrayofstring2)
 
 def MonsterStartTestarrayofstring2Vector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartTestarrayofstring2Vector(builder, numElems):
+def StartTestarrayofstring2Vector(builder, numElems: int) -> int:
     return MonsterStartTestarrayofstring2Vector(builder, numElems)
 
 def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
-    return builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
+    builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
 
-def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
+def AddTestarrayofsortedstruct(builder: flatbuffers.Builder, testarrayofsortedstruct: int):
-    return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
+    MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
 
 def MonsterStartTestarrayofsortedstructVector(builder, numElems):
     return builder.StartVector(8, numElems, 4)
 
-def StartTestarrayofsortedstructVector(builder, numElems):
+def StartTestarrayofsortedstructVector(builder, numElems: int) -> int:
     return MonsterStartTestarrayofsortedstructVector(builder, numElems)
 
 def MonsterAddFlex(builder, flex):
-    return builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
+    builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
 
-def AddFlex(builder, flex):
+def AddFlex(builder: flatbuffers.Builder, flex: int):
-    return MonsterAddFlex(builder, flex)
+    MonsterAddFlex(builder, flex)
 
 def MonsterStartFlexVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartFlexVector(builder, numElems):
+def StartFlexVector(builder, numElems: int) -> int:
     return MonsterStartFlexVector(builder, numElems)
 
 def MonsterAddTest5(builder, test5):
-    return builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
+    builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
 
-def AddTest5(builder, test5):
+def AddTest5(builder: flatbuffers.Builder, test5: int):
-    return MonsterAddTest5(builder, test5)
+    MonsterAddTest5(builder, test5)
 
 def MonsterStartTest5Vector(builder, numElems):
     return builder.StartVector(4, numElems, 2)
 
-def StartTest5Vector(builder, numElems):
+def StartTest5Vector(builder, numElems: int) -> int:
     return MonsterStartTest5Vector(builder, numElems)
 
 def MonsterAddVectorOfLongs(builder, vectorOfLongs):
-    return builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
+    builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
 
-def AddVectorOfLongs(builder, vectorOfLongs):
+def AddVectorOfLongs(builder: flatbuffers.Builder, vectorOfLongs: int):
-    return MonsterAddVectorOfLongs(builder, vectorOfLongs)
+    MonsterAddVectorOfLongs(builder, vectorOfLongs)
 
 def MonsterStartVectorOfLongsVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
-def StartVectorOfLongsVector(builder, numElems):
+def StartVectorOfLongsVector(builder, numElems: int) -> int:
     return MonsterStartVectorOfLongsVector(builder, numElems)
 
 def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
-    return builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
+    builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
 
-def AddVectorOfDoubles(builder, vectorOfDoubles):
+def AddVectorOfDoubles(builder: flatbuffers.Builder, vectorOfDoubles: int):
-    return MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
+    MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
 
 def MonsterStartVectorOfDoublesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
-def StartVectorOfDoublesVector(builder, numElems):
+def StartVectorOfDoublesVector(builder, numElems: int) -> int:
     return MonsterStartVectorOfDoublesVector(builder, numElems)
 
 def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
-    return builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
+    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
 
-def AddParentNamespaceTest(builder, parentNamespaceTest):
+def AddParentNamespaceTest(builder: flatbuffers.Builder, parentNamespaceTest: int):
-    return MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
+    MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
 
 def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
-    return builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
+    builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
 
-def AddVectorOfReferrables(builder, vectorOfReferrables):
+def AddVectorOfReferrables(builder: flatbuffers.Builder, vectorOfReferrables: int):
-    return MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
+    MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
 
 def MonsterStartVectorOfReferrablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartVectorOfReferrablesVector(builder, numElems):
+def StartVectorOfReferrablesVector(builder, numElems: int) -> int:
     return MonsterStartVectorOfReferrablesVector(builder, numElems)
 
 def MonsterAddSingleWeakReference(builder, singleWeakReference):
-    return builder.PrependUint64Slot(36, singleWeakReference, 0)
+    builder.PrependUint64Slot(36, singleWeakReference, 0)
 
-def AddSingleWeakReference(builder, singleWeakReference):
+def AddSingleWeakReference(builder: flatbuffers.Builder, singleWeakReference: int):
-    return MonsterAddSingleWeakReference(builder, singleWeakReference)
+    MonsterAddSingleWeakReference(builder, singleWeakReference)
 
 def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
-    return builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
+    builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
 
-def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
+def AddVectorOfWeakReferences(builder: flatbuffers.Builder, vectorOfWeakReferences: int):
-    return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
+    MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
 
 def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
-def StartVectorOfWeakReferencesVector(builder, numElems):
+def StartVectorOfWeakReferencesVector(builder, numElems: int) -> int:
     return MonsterStartVectorOfWeakReferencesVector(builder, numElems)
 
 def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
-    return builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
+    builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
 
-def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
+def AddVectorOfStrongReferrables(builder: flatbuffers.Builder, vectorOfStrongReferrables: int):
-    return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
+    MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
 
 def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartVectorOfStrongReferrablesVector(builder, numElems):
+def StartVectorOfStrongReferrablesVector(builder, numElems: int) -> int:
     return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)
 
 def MonsterAddCoOwningReference(builder, coOwningReference):
-    return builder.PrependUint64Slot(39, coOwningReference, 0)
+    builder.PrependUint64Slot(39, coOwningReference, 0)
 
-def AddCoOwningReference(builder, coOwningReference):
+def AddCoOwningReference(builder: flatbuffers.Builder, coOwningReference: int):
-    return MonsterAddCoOwningReference(builder, coOwningReference)
+    MonsterAddCoOwningReference(builder, coOwningReference)
 
 def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
-    return builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
+    builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
 
-def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
+def AddVectorOfCoOwningReferences(builder: flatbuffers.Builder, vectorOfCoOwningReferences: int):
-    return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
+    MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
 
 def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
-def StartVectorOfCoOwningReferencesVector(builder, numElems):
+def StartVectorOfCoOwningReferencesVector(builder, numElems: int) -> int:
     return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)
 
 def MonsterAddNonOwningReference(builder, nonOwningReference):
-    return builder.PrependUint64Slot(41, nonOwningReference, 0)
+    builder.PrependUint64Slot(41, nonOwningReference, 0)
 
-def AddNonOwningReference(builder, nonOwningReference):
+def AddNonOwningReference(builder: flatbuffers.Builder, nonOwningReference: int):
-    return MonsterAddNonOwningReference(builder, nonOwningReference)
+    MonsterAddNonOwningReference(builder, nonOwningReference)
 
 def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
-    return builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
+    builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
 
-def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
+def AddVectorOfNonOwningReferences(builder: flatbuffers.Builder, vectorOfNonOwningReferences: int):
-    return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
+    MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
 
 def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
-def StartVectorOfNonOwningReferencesVector(builder, numElems):
+def StartVectorOfNonOwningReferencesVector(builder, numElems: int) -> int:
     return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)
 
 def MonsterAddAnyUniqueType(builder, anyUniqueType):
-    return builder.PrependUint8Slot(43, anyUniqueType, 0)
+    builder.PrependUint8Slot(43, anyUniqueType, 0)
 
-def AddAnyUniqueType(builder, anyUniqueType):
+def AddAnyUniqueType(builder: flatbuffers.Builder, anyUniqueType: int):
-    return MonsterAddAnyUniqueType(builder, anyUniqueType)
+    MonsterAddAnyUniqueType(builder, anyUniqueType)
 
 def MonsterAddAnyUnique(builder, anyUnique):
-    return builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
+    builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
 
-def AddAnyUnique(builder, anyUnique):
+def AddAnyUnique(builder: flatbuffers.Builder, anyUnique: int):
-    return MonsterAddAnyUnique(builder, anyUnique)
+    MonsterAddAnyUnique(builder, anyUnique)
 
 def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
-    return builder.PrependUint8Slot(45, anyAmbiguousType, 0)
+    builder.PrependUint8Slot(45, anyAmbiguousType, 0)
 
-def AddAnyAmbiguousType(builder, anyAmbiguousType):
+def AddAnyAmbiguousType(builder: flatbuffers.Builder, anyAmbiguousType: int):
-    return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
+    MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
 
 def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
-    return builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+    builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
 
-def AddAnyAmbiguous(builder, anyAmbiguous):
+def AddAnyAmbiguous(builder: flatbuffers.Builder, anyAmbiguous: int):
-    return MonsterAddAnyAmbiguous(builder, anyAmbiguous)
+    MonsterAddAnyAmbiguous(builder, anyAmbiguous)
 
 def MonsterAddVectorOfEnums(builder, vectorOfEnums):
-    return builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+    builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
 
-def AddVectorOfEnums(builder, vectorOfEnums):
+def AddVectorOfEnums(builder: flatbuffers.Builder, vectorOfEnums: int):
-    return MonsterAddVectorOfEnums(builder, vectorOfEnums)
+    MonsterAddVectorOfEnums(builder, vectorOfEnums)
 
 def MonsterStartVectorOfEnumsVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartVectorOfEnumsVector(builder, numElems):
+def StartVectorOfEnumsVector(builder, numElems: int) -> int:
     return MonsterStartVectorOfEnumsVector(builder, numElems)
 
 def MonsterAddSignedEnum(builder, signedEnum):
-    return builder.PrependInt8Slot(48, signedEnum, -1)
+    builder.PrependInt8Slot(48, signedEnum, -1)
 
-def AddSignedEnum(builder, signedEnum):
+def AddSignedEnum(builder: flatbuffers.Builder, signedEnum: int):
-    return MonsterAddSignedEnum(builder, signedEnum)
+    MonsterAddSignedEnum(builder, signedEnum)
 
 def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
-    return builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+    builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
 
-def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
+def AddTestrequirednestedflatbuffer(builder: flatbuffers.Builder, testrequirednestedflatbuffer: int):
-    return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
+    MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
 
 def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartTestrequirednestedflatbufferVector(builder, numElems):
+def StartTestrequirednestedflatbufferVector(builder, numElems: int) -> int:
     return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)
 
 def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
@@ -1301,82 +1301,82 @@ def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
 def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes)
 def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
-    return builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
+    builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
 
-def AddScalarKeySortedTables(builder, scalarKeySortedTables):
+def AddScalarKeySortedTables(builder: flatbuffers.Builder, scalarKeySortedTables: int):
-    return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
+    MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
 
 def MonsterStartScalarKeySortedTablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
-def StartScalarKeySortedTablesVector(builder, numElems):
+def StartScalarKeySortedTablesVector(builder, numElems: int) -> int:
     return MonsterStartScalarKeySortedTablesVector(builder, numElems)
 
 def MonsterAddNativeInline(builder, nativeInline):
-    return builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
+    builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
 
-def AddNativeInline(builder, nativeInline):
+def AddNativeInline(builder: flatbuffers.Builder, nativeInline: Any):
-    return MonsterAddNativeInline(builder, nativeInline)
+    MonsterAddNativeInline(builder, nativeInline)
 
 def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
-    return builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
+    builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
 
-def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
+def AddLongEnumNonEnumDefault(builder: flatbuffers.Builder, longEnumNonEnumDefault: int):
-    return MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
+    MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
 
 def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault):
-    return builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
+    builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
 
-def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
+def AddLongEnumNormalDefault(builder: flatbuffers.Builder, longEnumNormalDefault: int):
-    return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
+    MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
 
 def MonsterAddNanDefault(builder, nanDefault):
-    return builder.PrependFloat32Slot(54, nanDefault, float('nan'))
+    builder.PrependFloat32Slot(54, nanDefault, float('nan'))
 
-def AddNanDefault(builder, nanDefault):
+def AddNanDefault(builder: flatbuffers.Builder, nanDefault: float):
-    return MonsterAddNanDefault(builder, nanDefault)
+    MonsterAddNanDefault(builder, nanDefault)
 
 def MonsterAddInfDefault(builder, infDefault):
-    return builder.PrependFloat32Slot(55, infDefault, float('inf'))
+    builder.PrependFloat32Slot(55, infDefault, float('inf'))
 
-def AddInfDefault(builder, infDefault):
+def AddInfDefault(builder: flatbuffers.Builder, infDefault: float):
-    return MonsterAddInfDefault(builder, infDefault)
+    MonsterAddInfDefault(builder, infDefault)
 
 def MonsterAddPositiveInfDefault(builder, positiveInfDefault):
-    return builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
+    builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
 
-def AddPositiveInfDefault(builder, positiveInfDefault):
+def AddPositiveInfDefault(builder: flatbuffers.Builder, positiveInfDefault: float):
-    return MonsterAddPositiveInfDefault(builder, positiveInfDefault)
+    MonsterAddPositiveInfDefault(builder, positiveInfDefault)
 
 def MonsterAddInfinityDefault(builder, infinityDefault):
-    return builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
+    builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
 
-def AddInfinityDefault(builder, infinityDefault):
+def AddInfinityDefault(builder: flatbuffers.Builder, infinityDefault: float):
-    return MonsterAddInfinityDefault(builder, infinityDefault)
+    MonsterAddInfinityDefault(builder, infinityDefault)
 
 def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault):
-    return builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
+    builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
 
-def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
+def AddPositiveInfinityDefault(builder: flatbuffers.Builder, positiveInfinityDefault: float):
-    return MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
+    MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
 
 def MonsterAddNegativeInfDefault(builder, negativeInfDefault):
-    return builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
+    builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
 
-def AddNegativeInfDefault(builder, negativeInfDefault):
+def AddNegativeInfDefault(builder: flatbuffers.Builder, negativeInfDefault: float):
-    return MonsterAddNegativeInfDefault(builder, negativeInfDefault)
+    MonsterAddNegativeInfDefault(builder, negativeInfDefault)
 
 def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault):
-    return builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
+    builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
 
-def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
+def AddNegativeInfinityDefault(builder: flatbuffers.Builder, negativeInfinityDefault: float):
-    return MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
+    MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
 
 def MonsterAddDoubleInfDefault(builder, doubleInfDefault):
-    return builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
+    builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
 
-def AddDoubleInfDefault(builder, doubleInfDefault):
+def AddDoubleInfDefault(builder: flatbuffers.Builder, doubleInfDefault: float):
-    return MonsterAddDoubleInfDefault(builder, doubleInfDefault)
+    MonsterAddDoubleInfDefault(builder, doubleInfDefault)
 
 def MonsterEnd(builder):
     return builder.EndObject()

tests/MyGame/Example/NestedStruct.py

@@ -4,17 +4,18 @@
 
 import flatbuffers
 from flatbuffers.compat import import_numpy
+from typing import Any
 np = import_numpy()
 
 class NestedStruct(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def SizeOf(cls):
+    def SizeOf(cls) -> int:
         return 32
 
     # NestedStruct
-    def Init(self, buf, pos):
+    def Init(self, buf: bytes, pos: int):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # NestedStruct
@@ -31,11 +32,11 @@ class NestedStruct(object):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 0, self.ALength())
 
     # NestedStruct
-    def ALength(self):
+    def ALength(self) -> int:
         return 2
 
     # NestedStruct
-    def AIsNone(self):
+    def AIsNone(self) -> bool:
         return False
 
     # NestedStruct
@@ -54,11 +55,11 @@ class NestedStruct(object):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int8Flags, self._tab.Pos + 9, self.CLength())
 
     # NestedStruct
-    def CLength(self):
+    def CLength(self) -> int:
         return 2
 
     # NestedStruct
-    def CIsNone(self):
+    def CIsNone(self) -> bool:
         return False
 
     # NestedStruct
@@ -75,11 +76,11 @@ class NestedStruct(object):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 16, self.DLength())
 
     # NestedStruct
-    def DLength(self):
+    def DLength(self) -> int:
         return 2
 
     # NestedStruct
-    def DIsNone(self):
+    def DIsNone(self) -> bool:
         return False
 
 

tests/MyGame/Example/NestedUnion/NestedUnionTest.py

@@ -4,13 +4,16 @@
 
 import flatbuffers
 from flatbuffers.compat import import_numpy
+from typing import Any
+from flatbuffers.table import Table
+from typing import Optional
 np = import_numpy()
 
 class NestedUnionTest(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def GetRootAs(cls, buf, offset=0):
+    def GetRootAs(cls, buf, offset: int = 0):
         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
         x = NestedUnionTest()
         x.Init(buf, n + offset)
@@ -21,11 +24,11 @@ class NestedUnionTest(object):
         """This method is deprecated. Please switch to GetRootAs."""
         return cls.GetRootAs(buf, offset)
     # NestedUnionTest
-    def Init(self, buf, pos):
+    def Init(self, buf: bytes, pos: int):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # NestedUnionTest
-    def Name(self):
+    def Name(self) -> Optional[str]:
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             return self._tab.String(o + self._tab.Pos)
@@ -39,10 +42,9 @@ class NestedUnionTest(object):
         return 0
 
     # NestedUnionTest
-    def Data(self):
+    def Data(self) -> Optional[flatbuffers.table.Table]:
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         if o != 0:
-            from flatbuffers.table import Table
             obj = Table(bytearray(), 0)
             self._tab.Union(obj, o)
             return obj
@@ -55,40 +57,40 @@ class NestedUnionTest(object):
             return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
         return 0
 
-def NestedUnionTestStart(builder):
+def NestedUnionTestStart(builder: flatbuffers.Builder):
-    return builder.StartObject(4)
+    builder.StartObject(4)
 
-def Start(builder):
+def Start(builder: flatbuffers.Builder):
-    return NestedUnionTestStart(builder)
+    NestedUnionTestStart(builder)
 
-def NestedUnionTestAddName(builder, name):
+def NestedUnionTestAddName(builder: flatbuffers.Builder, name: int):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder, name):
+def AddName(builder: flatbuffers.Builder, name: int):
-    return NestedUnionTestAddName(builder, name)
+    NestedUnionTestAddName(builder, name)
 
-def NestedUnionTestAddDataType(builder, dataType):
+def NestedUnionTestAddDataType(builder: flatbuffers.Builder, dataType: int):
-    return builder.PrependUint8Slot(1, dataType, 0)
+    builder.PrependUint8Slot(1, dataType, 0)
 
-def AddDataType(builder, dataType):
+def AddDataType(builder: flatbuffers.Builder, dataType: int):
-    return NestedUnionTestAddDataType(builder, dataType)
+    NestedUnionTestAddDataType(builder, dataType)
 
-def NestedUnionTestAddData(builder, data):
+def NestedUnionTestAddData(builder: flatbuffers.Builder, data: int):
-    return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
 
-def AddData(builder, data):
+def AddData(builder: flatbuffers.Builder, data: int):
-    return NestedUnionTestAddData(builder, data)
+    NestedUnionTestAddData(builder, data)
 
-def NestedUnionTestAddId(builder, id):
+def NestedUnionTestAddId(builder: flatbuffers.Builder, id: int):
-    return builder.PrependInt16Slot(3, id, 0)
+    builder.PrependInt16Slot(3, id, 0)
 
-def AddId(builder, id):
+def AddId(builder: flatbuffers.Builder, id: int):
-    return NestedUnionTestAddId(builder, id)
+    NestedUnionTestAddId(builder, id)
 
-def NestedUnionTestEnd(builder):
+def NestedUnionTestEnd(builder: flatbuffers.Builder) -> int:
     return builder.EndObject()
 
-def End(builder):
+def End(builder: flatbuffers.Builder) -> int:
     return NestedUnionTestEnd(builder)
 
 import MyGame.Example.NestedUnion.Any

tests/MyGame/Example/NestedUnion/Test.py

@@ -4,17 +4,18 @@
 
 import flatbuffers
 from flatbuffers.compat import import_numpy
+from typing import Any
 np = import_numpy()
 
 class Test(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def SizeOf(cls):
+    def SizeOf(cls) -> int:
         return 4
 
     # Test
-    def Init(self, buf, pos):
+    def Init(self, buf: bytes, pos: int):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # Test

tests/MyGame/Example/NestedUnion/TestSimpleTableWithEnum.py

@@ -4,13 +4,14 @@
 
 import flatbuffers
 from flatbuffers.compat import import_numpy
+from typing import Any
 np = import_numpy()
 
 class TestSimpleTableWithEnum(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def GetRootAs(cls, buf, offset=0):
+    def GetRootAs(cls, buf, offset: int = 0):
         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
         x = TestSimpleTableWithEnum()
         x.Init(buf, n + offset)
@@ -21,7 +22,7 @@ class TestSimpleTableWithEnum(object):
         """This method is deprecated. Please switch to GetRootAs."""
         return cls.GetRootAs(buf, offset)
     # TestSimpleTableWithEnum
-    def Init(self, buf, pos):
+    def Init(self, buf: bytes, pos: int):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # TestSimpleTableWithEnum
@@ -31,22 +32,22 @@ class TestSimpleTableWithEnum(object):
             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
         return 2
 
-def TestSimpleTableWithEnumStart(builder):
+def TestSimpleTableWithEnumStart(builder: flatbuffers.Builder):
-    return builder.StartObject(1)
+    builder.StartObject(1)
 
-def Start(builder):
+def Start(builder: flatbuffers.Builder):
-    return TestSimpleTableWithEnumStart(builder)
+    TestSimpleTableWithEnumStart(builder)
 
-def TestSimpleTableWithEnumAddColor(builder, color):
+def TestSimpleTableWithEnumAddColor(builder: flatbuffers.Builder, color: int):
-    return builder.PrependUint8Slot(0, color, 2)
+    builder.PrependUint8Slot(0, color, 2)
 
-def AddColor(builder, color):
+def AddColor(builder: flatbuffers.Builder, color: int):
-    return TestSimpleTableWithEnumAddColor(builder, color)
+    TestSimpleTableWithEnumAddColor(builder, color)
 
-def TestSimpleTableWithEnumEnd(builder):
+def TestSimpleTableWithEnumEnd(builder: flatbuffers.Builder) -> int:
     return builder.EndObject()
 
-def End(builder):
+def End(builder: flatbuffers.Builder) -> int:
     return TestSimpleTableWithEnumEnd(builder)
 
 

tests/MyGame/Example/NestedUnion/Vec3.py

@@ -4,13 +4,16 @@
 
 import flatbuffers
 from flatbuffers.compat import import_numpy
+from typing import Any
+from .MyGame.Example.NestedUnion.Test import Test
+from typing import Optional
 np = import_numpy()
 
 class Vec3(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def GetRootAs(cls, buf, offset=0):
+    def GetRootAs(cls, buf, offset: int = 0):
         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
         x = Vec3()
         x.Init(buf, n + offset)
@@ -21,7 +24,7 @@ class Vec3(object):
         """This method is deprecated. Please switch to GetRootAs."""
         return cls.GetRootAs(buf, offset)
     # Vec3
-    def Init(self, buf, pos):
+    def Init(self, buf: bytes, pos: int):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # Vec3
@@ -60,62 +63,61 @@ class Vec3(object):
         return 0
 
     # Vec3
-    def Test3(self):
+    def Test3(self) -> Optional[Test]:
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
             x = o + self._tab.Pos
-            from MyGame.Example.NestedUnion.Test import Test
             obj = Test()
             obj.Init(self._tab.Bytes, x)
             return obj
         return None
 
-def Vec3Start(builder):
+def Vec3Start(builder: flatbuffers.Builder):
-    return builder.StartObject(6)
+    builder.StartObject(6)
 
-def Start(builder):
+def Start(builder: flatbuffers.Builder):
-    return Vec3Start(builder)
+    Vec3Start(builder)
 
-def Vec3AddX(builder, x):
+def Vec3AddX(builder: flatbuffers.Builder, x: float):
-    return builder.PrependFloat64Slot(0, x, 0.0)
+    builder.PrependFloat64Slot(0, x, 0.0)
 
-def AddX(builder, x):
+def AddX(builder: flatbuffers.Builder, x: float):
-    return Vec3AddX(builder, x)
+    Vec3AddX(builder, x)
 
-def Vec3AddY(builder, y):
+def Vec3AddY(builder: flatbuffers.Builder, y: float):
-    return builder.PrependFloat64Slot(1, y, 0.0)
+    builder.PrependFloat64Slot(1, y, 0.0)
 
-def AddY(builder, y):
+def AddY(builder: flatbuffers.Builder, y: float):
-    return Vec3AddY(builder, y)
+    Vec3AddY(builder, y)
 
-def Vec3AddZ(builder, z):
+def Vec3AddZ(builder: flatbuffers.Builder, z: float):
-    return builder.PrependFloat64Slot(2, z, 0.0)
+    builder.PrependFloat64Slot(2, z, 0.0)
 
-def AddZ(builder, z):
+def AddZ(builder: flatbuffers.Builder, z: float):
-    return Vec3AddZ(builder, z)
+    Vec3AddZ(builder, z)
 
-def Vec3AddTest1(builder, test1):
+def Vec3AddTest1(builder: flatbuffers.Builder, test1: float):
-    return builder.PrependFloat64Slot(3, test1, 0.0)
+    builder.PrependFloat64Slot(3, test1, 0.0)
 
-def AddTest1(builder, test1):
+def AddTest1(builder: flatbuffers.Builder, test1: float):
-    return Vec3AddTest1(builder, test1)
+    Vec3AddTest1(builder, test1)
 
-def Vec3AddTest2(builder, test2):
+def Vec3AddTest2(builder: flatbuffers.Builder, test2: int):
-    return builder.PrependUint8Slot(4, test2, 0)
+    builder.PrependUint8Slot(4, test2, 0)
 
-def AddTest2(builder, test2):
+def AddTest2(builder: flatbuffers.Builder, test2: int):
-    return Vec3AddTest2(builder, test2)
+    Vec3AddTest2(builder, test2)
 
-def Vec3AddTest3(builder, test3):
+def Vec3AddTest3(builder: flatbuffers.Builder, test3: Any):
-    return builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(test3), 0)
+    builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(test3), 0)
 
-def AddTest3(builder, test3):
+def AddTest3(builder: flatbuffers.Builder, test3: Any):
-    return Vec3AddTest3(builder, test3)
+    Vec3AddTest3(builder, test3)
 
-def Vec3End(builder):
+def Vec3End(builder: flatbuffers.Builder) -> int:
     return builder.EndObject()
 
-def End(builder):
+def End(builder: flatbuffers.Builder) -> int:
     return Vec3End(builder)
 
 import MyGame.Example.NestedUnion.Test

tests/MyGame/Example/Referrable.py

@@ -36,16 +36,16 @@ class Referrable(object):
         return 0
 
 def ReferrableStart(builder):
-    return builder.StartObject(1)
+    builder.StartObject(1)
 
 def Start(builder):
-    return ReferrableStart(builder)
+    ReferrableStart(builder)
 
 def ReferrableAddId(builder, id):
-    return builder.PrependUint64Slot(0, id, 0)
+    builder.PrependUint64Slot(0, id, 0)
 
-def AddId(builder, id):
+def AddId(builder: flatbuffers.Builder, id: int):
-    return ReferrableAddId(builder, id)
+    ReferrableAddId(builder, id)
 
 def ReferrableEnd(builder):
     return builder.EndObject()

tests/MyGame/Example/Stat.py

@@ -50,28 +50,28 @@ class Stat(object):
         return 0
 
 def StatStart(builder):
-    return builder.StartObject(3)
+    builder.StartObject(3)
 
 def Start(builder):
-    return StatStart(builder)
+    StatStart(builder)
 
 def StatAddId(builder, id):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
 
-def AddId(builder, id):
+def AddId(builder: flatbuffers.Builder, id: int):
-    return StatAddId(builder, id)
+    StatAddId(builder, id)
 
 def StatAddVal(builder, val):
-    return builder.PrependInt64Slot(1, val, 0)
+    builder.PrependInt64Slot(1, val, 0)
 
-def AddVal(builder, val):
+def AddVal(builder: flatbuffers.Builder, val: int):
-    return StatAddVal(builder, val)
+    StatAddVal(builder, val)
 
 def StatAddCount(builder, count):
-    return builder.PrependUint16Slot(2, count, 0)
+    builder.PrependUint16Slot(2, count, 0)
 
-def AddCount(builder, count):
+def AddCount(builder: flatbuffers.Builder, count: int):
-    return StatAddCount(builder, count)
+    StatAddCount(builder, count)
 
 def StatEnd(builder):
     return builder.EndObject()

tests/MyGame/Example/TestSimpleTableWithEnum.py

@@ -36,16 +36,16 @@ class TestSimpleTableWithEnum(object):
         return 2
 
 def TestSimpleTableWithEnumStart(builder):
-    return builder.StartObject(1)
+    builder.StartObject(1)
 
 def Start(builder):
-    return TestSimpleTableWithEnumStart(builder)
+    TestSimpleTableWithEnumStart(builder)
 
 def TestSimpleTableWithEnumAddColor(builder, color):
-    return builder.PrependUint8Slot(0, color, 2)
+    builder.PrependUint8Slot(0, color, 2)
 
-def AddColor(builder, color):
+def AddColor(builder: flatbuffers.Builder, color: int):
-    return TestSimpleTableWithEnumAddColor(builder, color)
+    TestSimpleTableWithEnumAddColor(builder, color)
 
 def TestSimpleTableWithEnumEnd(builder):
     return builder.EndObject()

tests/MyGame/Example/TypeAliases.py

@@ -153,93 +153,93 @@ class TypeAliases(object):
         return o == 0
 
 def TypeAliasesStart(builder):
-    return builder.StartObject(12)
+    builder.StartObject(12)
 
 def Start(builder):
-    return TypeAliasesStart(builder)
+    TypeAliasesStart(builder)
 
 def TypeAliasesAddI8(builder, i8):
-    return builder.PrependInt8Slot(0, i8, 0)
+    builder.PrependInt8Slot(0, i8, 0)
 
-def AddI8(builder, i8):
+def AddI8(builder: flatbuffers.Builder, i8: int):
-    return TypeAliasesAddI8(builder, i8)
+    TypeAliasesAddI8(builder, i8)
 
 def TypeAliasesAddU8(builder, u8):
-    return builder.PrependUint8Slot(1, u8, 0)
+    builder.PrependUint8Slot(1, u8, 0)
 
-def AddU8(builder, u8):
+def AddU8(builder: flatbuffers.Builder, u8: int):
-    return TypeAliasesAddU8(builder, u8)
+    TypeAliasesAddU8(builder, u8)
 
 def TypeAliasesAddI16(builder, i16):
-    return builder.PrependInt16Slot(2, i16, 0)
+    builder.PrependInt16Slot(2, i16, 0)
 
-def AddI16(builder, i16):
+def AddI16(builder: flatbuffers.Builder, i16: int):
-    return TypeAliasesAddI16(builder, i16)
+    TypeAliasesAddI16(builder, i16)
 
 def TypeAliasesAddU16(builder, u16):
-    return builder.PrependUint16Slot(3, u16, 0)
+    builder.PrependUint16Slot(3, u16, 0)
 
-def AddU16(builder, u16):
+def AddU16(builder: flatbuffers.Builder, u16: int):
-    return TypeAliasesAddU16(builder, u16)
+    TypeAliasesAddU16(builder, u16)
 
 def TypeAliasesAddI32(builder, i32):
-    return builder.PrependInt32Slot(4, i32, 0)
+    builder.PrependInt32Slot(4, i32, 0)
 
-def AddI32(builder, i32):
+def AddI32(builder: flatbuffers.Builder, i32: int):
-    return TypeAliasesAddI32(builder, i32)
+    TypeAliasesAddI32(builder, i32)
 
 def TypeAliasesAddU32(builder, u32):
-    return builder.PrependUint32Slot(5, u32, 0)
+    builder.PrependUint32Slot(5, u32, 0)
 
-def AddU32(builder, u32):
+def AddU32(builder: flatbuffers.Builder, u32: int):
-    return TypeAliasesAddU32(builder, u32)
+    TypeAliasesAddU32(builder, u32)
 
 def TypeAliasesAddI64(builder, i64):
-    return builder.PrependInt64Slot(6, i64, 0)
+    builder.PrependInt64Slot(6, i64, 0)
 
-def AddI64(builder, i64):
+def AddI64(builder: flatbuffers.Builder, i64: int):
-    return TypeAliasesAddI64(builder, i64)
+    TypeAliasesAddI64(builder, i64)
 
 def TypeAliasesAddU64(builder, u64):
-    return builder.PrependUint64Slot(7, u64, 0)
+    builder.PrependUint64Slot(7, u64, 0)
 
-def AddU64(builder, u64):
+def AddU64(builder: flatbuffers.Builder, u64: int):
-    return TypeAliasesAddU64(builder, u64)
+    TypeAliasesAddU64(builder, u64)
 
 def TypeAliasesAddF32(builder, f32):
-    return builder.PrependFloat32Slot(8, f32, 0.0)
+    builder.PrependFloat32Slot(8, f32, 0.0)
 
-def AddF32(builder, f32):
+def AddF32(builder: flatbuffers.Builder, f32: float):
-    return TypeAliasesAddF32(builder, f32)
+    TypeAliasesAddF32(builder, f32)
 
 def TypeAliasesAddF64(builder, f64):
-    return builder.PrependFloat64Slot(9, f64, 0.0)
+    builder.PrependFloat64Slot(9, f64, 0.0)
 
-def AddF64(builder, f64):
+def AddF64(builder: flatbuffers.Builder, f64: float):
-    return TypeAliasesAddF64(builder, f64)
+    TypeAliasesAddF64(builder, f64)
 
 def TypeAliasesAddV8(builder, v8):
-    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
 
-def AddV8(builder, v8):
+def AddV8(builder: flatbuffers.Builder, v8: int):
-    return TypeAliasesAddV8(builder, v8)
+    TypeAliasesAddV8(builder, v8)
 
 def TypeAliasesStartV8Vector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartV8Vector(builder, numElems):
+def StartV8Vector(builder, numElems: int) -> int:
     return TypeAliasesStartV8Vector(builder, numElems)
 
 def TypeAliasesAddVf64(builder, vf64):
-    return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
 
-def AddVf64(builder, vf64):
+def AddVf64(builder: flatbuffers.Builder, vf64: int):
-    return TypeAliasesAddVf64(builder, vf64)
+    TypeAliasesAddVf64(builder, vf64)
 
 def TypeAliasesStartVf64Vector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
-def StartVf64Vector(builder, numElems):
+def StartVf64Vector(builder, numElems: int) -> int:
     return TypeAliasesStartVf64Vector(builder, numElems)
 
 def TypeAliasesEnd(builder):

tests/MyGame/Example2/Monster.py

@@ -29,10 +29,10 @@ class Monster(object):
         self._tab = flatbuffers.table.Table(buf, pos)
 
 def MonsterStart(builder):
-    return builder.StartObject(0)
+    builder.StartObject(0)
 
 def Start(builder):
-    return MonsterStart(builder)
+    MonsterStart(builder)
 
 def MonsterEnd(builder):
     return builder.EndObject()

tests/MyGame/InParentNamespace.py

@@ -29,10 +29,10 @@ class InParentNamespace(object):
         self._tab = flatbuffers.table.Table(buf, pos)
 
 def InParentNamespaceStart(builder):
-    return builder.StartObject(0)
+    builder.StartObject(0)
 
 def Start(builder):
-    return InParentNamespaceStart(builder)
+    InParentNamespaceStart(builder)
 
 def InParentNamespaceEnd(builder):
     return builder.EndObject()

tests/MyGame/MonsterExtra.py

@@ -4,13 +4,14 @@
 
 import flatbuffers
 from flatbuffers.compat import import_numpy
+from typing import Any
 np = import_numpy()
 
 class MonsterExtra(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def GetRootAs(cls, buf, offset=0):
+    def GetRootAs(cls, buf, offset: int = 0):
         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
         x = MonsterExtra()
         x.Init(buf, n + offset)
@@ -25,7 +26,7 @@ class MonsterExtra(object):
         return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x45", size_prefixed=size_prefixed)
 
     # MonsterExtra
-    def Init(self, buf, pos):
+    def Init(self, buf: bytes, pos: int):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # MonsterExtra
@@ -85,7 +86,7 @@ class MonsterExtra(object):
         return float('-inf')
 
     # MonsterExtra
-    def Dvec(self, j):
+    def Dvec(self, j: int):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
         if o != 0:
             a = self._tab.Vector(o)
@@ -100,19 +101,19 @@ class MonsterExtra(object):
         return 0
 
     # MonsterExtra
-    def DvecLength(self):
+    def DvecLength(self) -> int:
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
         if o != 0:
             return self._tab.VectorLen(o)
         return 0
 
     # MonsterExtra
-    def DvecIsNone(self):
+    def DvecIsNone(self) -> bool:
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
         return o == 0
 
     # MonsterExtra
-    def Fvec(self, j):
+    def Fvec(self, j: int):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
             a = self._tab.Vector(o)
@@ -127,99 +128,99 @@ class MonsterExtra(object):
         return 0
 
     # MonsterExtra
-    def FvecLength(self):
+    def FvecLength(self) -> int:
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
             return self._tab.VectorLen(o)
         return 0
 
     # MonsterExtra
-    def FvecIsNone(self):
+    def FvecIsNone(self) -> bool:
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         return o == 0
 
-def MonsterExtraStart(builder):
+def MonsterExtraStart(builder: flatbuffers.Builder):
-    return builder.StartObject(11)
+    builder.StartObject(11)
 
-def Start(builder):
+def Start(builder: flatbuffers.Builder):
-    return MonsterExtraStart(builder)
+    MonsterExtraStart(builder)
 
-def MonsterExtraAddD0(builder, d0):
+def MonsterExtraAddD0(builder: flatbuffers.Builder, d0: float):
-    return builder.PrependFloat64Slot(0, d0, float('nan'))
+    builder.PrependFloat64Slot(0, d0, float('nan'))
 
-def AddD0(builder, d0):
+def AddD0(builder: flatbuffers.Builder, d0: float):
-    return MonsterExtraAddD0(builder, d0)
+    MonsterExtraAddD0(builder, d0)
 
-def MonsterExtraAddD1(builder, d1):
+def MonsterExtraAddD1(builder: flatbuffers.Builder, d1: float):
-    return builder.PrependFloat64Slot(1, d1, float('nan'))
+    builder.PrependFloat64Slot(1, d1, float('nan'))
 
-def AddD1(builder, d1):
+def AddD1(builder: flatbuffers.Builder, d1: float):
-    return MonsterExtraAddD1(builder, d1)
+    MonsterExtraAddD1(builder, d1)
 
-def MonsterExtraAddD2(builder, d2):
+def MonsterExtraAddD2(builder: flatbuffers.Builder, d2: float):
-    return builder.PrependFloat64Slot(2, d2, float('inf'))
+    builder.PrependFloat64Slot(2, d2, float('inf'))
 
-def AddD2(builder, d2):
+def AddD2(builder: flatbuffers.Builder, d2: float):
-    return MonsterExtraAddD2(builder, d2)
+    MonsterExtraAddD2(builder, d2)
 
-def MonsterExtraAddD3(builder, d3):
+def MonsterExtraAddD3(builder: flatbuffers.Builder, d3: float):
-    return builder.PrependFloat64Slot(3, d3, float('-inf'))
+    builder.PrependFloat64Slot(3, d3, float('-inf'))
 
-def AddD3(builder, d3):
+def AddD3(builder: flatbuffers.Builder, d3: float):
-    return MonsterExtraAddD3(builder, d3)
+    MonsterExtraAddD3(builder, d3)
 
-def MonsterExtraAddF0(builder, f0):
+def MonsterExtraAddF0(builder: flatbuffers.Builder, f0: float):
-    return builder.PrependFloat32Slot(4, f0, float('nan'))
+    builder.PrependFloat32Slot(4, f0, float('nan'))
 
-def AddF0(builder, f0):
+def AddF0(builder: flatbuffers.Builder, f0: float):
-    return MonsterExtraAddF0(builder, f0)
+    MonsterExtraAddF0(builder, f0)
 
-def MonsterExtraAddF1(builder, f1):
+def MonsterExtraAddF1(builder: flatbuffers.Builder, f1: float):
-    return builder.PrependFloat32Slot(5, f1, float('nan'))
+    builder.PrependFloat32Slot(5, f1, float('nan'))
 
-def AddF1(builder, f1):
+def AddF1(builder: flatbuffers.Builder, f1: float):
-    return MonsterExtraAddF1(builder, f1)
+    MonsterExtraAddF1(builder, f1)
 
-def MonsterExtraAddF2(builder, f2):
+def MonsterExtraAddF2(builder: flatbuffers.Builder, f2: float):
-    return builder.PrependFloat32Slot(6, f2, float('inf'))
+    builder.PrependFloat32Slot(6, f2, float('inf'))
 
-def AddF2(builder, f2):
+def AddF2(builder: flatbuffers.Builder, f2: float):
-    return MonsterExtraAddF2(builder, f2)
+    MonsterExtraAddF2(builder, f2)
 
-def MonsterExtraAddF3(builder, f3):
+def MonsterExtraAddF3(builder: flatbuffers.Builder, f3: float):
-    return builder.PrependFloat32Slot(7, f3, float('-inf'))
+    builder.PrependFloat32Slot(7, f3, float('-inf'))
 
-def AddF3(builder, f3):
+def AddF3(builder: flatbuffers.Builder, f3: float):
-    return MonsterExtraAddF3(builder, f3)
+    MonsterExtraAddF3(builder, f3)
 
-def MonsterExtraAddDvec(builder, dvec):
+def MonsterExtraAddDvec(builder: flatbuffers.Builder, dvec: int):
-    return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
 
-def AddDvec(builder, dvec):
+def AddDvec(builder: flatbuffers.Builder, dvec: int):
-    return MonsterExtraAddDvec(builder, dvec)
+    MonsterExtraAddDvec(builder, dvec)
 
-def MonsterExtraStartDvecVector(builder, numElems):
+def MonsterExtraStartDvecVector(builder, numElems: int) -> int:
     return builder.StartVector(8, numElems, 8)
 
-def StartDvecVector(builder, numElems):
+def StartDvecVector(builder, numElems: int) -> int:
     return MonsterExtraStartDvecVector(builder, numElems)
 
-def MonsterExtraAddFvec(builder, fvec):
+def MonsterExtraAddFvec(builder: flatbuffers.Builder, fvec: int):
-    return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
 
-def AddFvec(builder, fvec):
+def AddFvec(builder: flatbuffers.Builder, fvec: int):
-    return MonsterExtraAddFvec(builder, fvec)
+    MonsterExtraAddFvec(builder, fvec)
 
-def MonsterExtraStartFvecVector(builder, numElems):
+def MonsterExtraStartFvecVector(builder, numElems: int) -> int:
     return builder.StartVector(4, numElems, 4)
 
-def StartFvecVector(builder, numElems):
+def StartFvecVector(builder, numElems: int) -> int:
     return MonsterExtraStartFvecVector(builder, numElems)
 
-def MonsterExtraEnd(builder):
+def MonsterExtraEnd(builder: flatbuffers.Builder) -> int:
     return builder.EndObject()
 
-def End(builder):
+def End(builder: flatbuffers.Builder) -> int:
     return MonsterExtraEnd(builder)
 
 try:

tests/monster_test_generated.py

@@ -109,7 +109,7 @@ class InParentNamespace(object):
         self._tab = flatbuffers.table.Table(buf, pos)
 
 def InParentNamespaceStart(builder):
-    return builder.StartObject(0)
+    builder.StartObject(0)
 
 def InParentNamespaceEnd(builder):
     return builder.EndObject()
@@ -174,7 +174,7 @@ class Monster(object):
         self._tab = flatbuffers.table.Table(buf, pos)
 
 def MonsterStart(builder):
-    return builder.StartObject(0)
+    builder.StartObject(0)
 
 def MonsterEnd(builder):
     return builder.EndObject()
@@ -306,10 +306,10 @@ class TestSimpleTableWithEnum(object):
         return 2
 
 def TestSimpleTableWithEnumStart(builder):
-    return builder.StartObject(1)
+    builder.StartObject(1)
 
 def TestSimpleTableWithEnumAddColor(builder, color):
-    return builder.PrependUint8Slot(0, color, 2)
+    builder.PrependUint8Slot(0, color, 2)
 
 def TestSimpleTableWithEnumEnd(builder):
     return builder.EndObject()
@@ -708,16 +708,16 @@ class Stat(object):
         return 0
 
 def StatStart(builder):
-    return builder.StartObject(3)
+    builder.StartObject(3)
 
 def StatAddId(builder, id):
-    return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
 
 def StatAddVal(builder, val):
-    return builder.PrependInt64Slot(1, val, 0)
+    builder.PrependInt64Slot(1, val, 0)
 
 def StatAddCount(builder, count):
-    return builder.PrependUint16Slot(2, count, 0)
+    builder.PrependUint16Slot(2, count, 0)
 
 def StatEnd(builder):
     return builder.EndObject()
@@ -800,10 +800,10 @@ class Referrable(object):
         return 0
 
 def ReferrableStart(builder):
-    return builder.StartObject(1)
+    builder.StartObject(1)
 
 def ReferrableAddId(builder, id):
-    return builder.PrependUint64Slot(0, id, 0)
+    builder.PrependUint64Slot(0, id, 0)
 
 def ReferrableEnd(builder):
     return builder.EndObject()
@@ -1050,7 +1050,7 @@ class Monster(object):
     def TestnestedflatbufferNestedRoot(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-            from MyGame.Example.Monster import Monster
+            from .MyGame.Example.Monster import Monster
             return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
@@ -1581,7 +1581,7 @@ class Monster(object):
     def TestrequirednestedflatbufferNestedRoot(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
-            from MyGame.Example.Monster import Monster
+            from .MyGame.Example.Monster import Monster
             return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
@@ -1702,58 +1702,58 @@ class Monster(object):
         return float('inf')
 
 def MonsterStart(builder):
-    return builder.StartObject(62)
+    builder.StartObject(62)
 
 def MonsterAddPos(builder, pos):
-    return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
+    builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
 
 def MonsterAddMana(builder, mana):
-    return builder.PrependInt16Slot(1, mana, 150)
+    builder.PrependInt16Slot(1, mana, 150)
 
 def MonsterAddHp(builder, hp):
-    return builder.PrependInt16Slot(2, hp, 100)
+    builder.PrependInt16Slot(2, hp, 100)
 
 def MonsterAddName(builder, name):
-    return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
 def MonsterAddInventory(builder, inventory):
-    return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
 
 def MonsterStartInventoryVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
 def MonsterAddColor(builder, color):
-    return builder.PrependUint8Slot(6, color, 8)
+    builder.PrependUint8Slot(6, color, 8)
 
 def MonsterAddTestType(builder, testType):
-    return builder.PrependUint8Slot(7, testType, 0)
+    builder.PrependUint8Slot(7, testType, 0)
 
 def MonsterAddTest(builder, test):
-    return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
 
 def MonsterAddTest4(builder, test4):
-    return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
 
 def MonsterStartTest4Vector(builder, numElems):
     return builder.StartVector(4, numElems, 2)
 
 def MonsterAddTestarrayofstring(builder, testarrayofstring):
-    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
 
 def MonsterStartTestarrayofstringVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
 def MonsterAddTestarrayoftables(builder, testarrayoftables):
-    return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
 
 def MonsterStartTestarrayoftablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
 def MonsterAddEnemy(builder, enemy):
-    return builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
+    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
 
 def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
-    return builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
+    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
 
 def MonsterStartTestnestedflatbufferVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
@@ -1764,151 +1764,151 @@ def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
     return builder.EndVector()
 def MonsterAddTestempty(builder, testempty):
-    return builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
+    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
 
 def MonsterAddTestbool(builder, testbool):
-    return builder.PrependBoolSlot(15, testbool, 0)
+    builder.PrependBoolSlot(15, testbool, 0)
 
 def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
-    return builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
+    builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
 
 def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
-    return builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
+    builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
 
 def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
-    return builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
+    builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
 
 def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
-    return builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
+    builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
 
 def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
-    return builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
+    builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
 
 def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
-    return builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
+    builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
 
 def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
-    return builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
+    builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
 
 def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
-    return builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
+    builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
 
 def MonsterAddTestarrayofbools(builder, testarrayofbools):
-    return builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
+    builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
 
 def MonsterStartTestarrayofboolsVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
 def MonsterAddTestf(builder, testf):
-    return builder.PrependFloat32Slot(25, testf, 3.14159)
+    builder.PrependFloat32Slot(25, testf, 3.14159)
 
 def MonsterAddTestf2(builder, testf2):
-    return builder.PrependFloat32Slot(26, testf2, 3.0)
+    builder.PrependFloat32Slot(26, testf2, 3.0)
 
 def MonsterAddTestf3(builder, testf3):
-    return builder.PrependFloat32Slot(27, testf3, 0.0)
+    builder.PrependFloat32Slot(27, testf3, 0.0)
 
 def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
-    return builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
+    builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
 
 def MonsterStartTestarrayofstring2Vector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
 def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
-    return builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
+    builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
 
 def MonsterStartTestarrayofsortedstructVector(builder, numElems):
     return builder.StartVector(8, numElems, 4)
 
 def MonsterAddFlex(builder, flex):
-    return builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
+    builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
 
 def MonsterStartFlexVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
 def MonsterAddTest5(builder, test5):
-    return builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
+    builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
 
 def MonsterStartTest5Vector(builder, numElems):
     return builder.StartVector(4, numElems, 2)
 
 def MonsterAddVectorOfLongs(builder, vectorOfLongs):
-    return builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
+    builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
 
 def MonsterStartVectorOfLongsVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
 def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
-    return builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
+    builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
 
 def MonsterStartVectorOfDoublesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
 def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
-    return builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
+    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
 
 def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
-    return builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
+    builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
 
 def MonsterStartVectorOfReferrablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
 def MonsterAddSingleWeakReference(builder, singleWeakReference):
-    return builder.PrependUint64Slot(36, singleWeakReference, 0)
+    builder.PrependUint64Slot(36, singleWeakReference, 0)
 
 def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
-    return builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
+    builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
 
 def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
 def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
-    return builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
+    builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
 
 def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
 def MonsterAddCoOwningReference(builder, coOwningReference):
-    return builder.PrependUint64Slot(39, coOwningReference, 0)
+    builder.PrependUint64Slot(39, coOwningReference, 0)
 
 def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
-    return builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
+    builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
 
 def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
 def MonsterAddNonOwningReference(builder, nonOwningReference):
-    return builder.PrependUint64Slot(41, nonOwningReference, 0)
+    builder.PrependUint64Slot(41, nonOwningReference, 0)
 
 def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
-    return builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
+    builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
 
 def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
     return builder.StartVector(8, numElems, 8)
 
 def MonsterAddAnyUniqueType(builder, anyUniqueType):
-    return builder.PrependUint8Slot(43, anyUniqueType, 0)
+    builder.PrependUint8Slot(43, anyUniqueType, 0)
 
 def MonsterAddAnyUnique(builder, anyUnique):
-    return builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
+    builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
 
 def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
-    return builder.PrependUint8Slot(45, anyAmbiguousType, 0)
+    builder.PrependUint8Slot(45, anyAmbiguousType, 0)
 
 def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
-    return builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+    builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
 
 def MonsterAddVectorOfEnums(builder, vectorOfEnums):
-    return builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+    builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
 
 def MonsterStartVectorOfEnumsVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
 def MonsterAddSignedEnum(builder, signedEnum):
-    return builder.PrependInt8Slot(48, signedEnum, -1)
+    builder.PrependInt8Slot(48, signedEnum, -1)
 
 def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
-    return builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+    builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
 
 def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
@@ -1919,43 +1919,43 @@ def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
     return builder.EndVector()
 def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
-    return builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
+    builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
 
 def MonsterStartScalarKeySortedTablesVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
 def MonsterAddNativeInline(builder, nativeInline):
-    return builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
+    builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
 
 def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
-    return builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
+    builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
 
 def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault):
-    return builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
+    builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
 
 def MonsterAddNanDefault(builder, nanDefault):
-    return builder.PrependFloat32Slot(54, nanDefault, float('nan'))
+    builder.PrependFloat32Slot(54, nanDefault, float('nan'))
 
 def MonsterAddInfDefault(builder, infDefault):
-    return builder.PrependFloat32Slot(55, infDefault, float('inf'))
+    builder.PrependFloat32Slot(55, infDefault, float('inf'))
 
 def MonsterAddPositiveInfDefault(builder, positiveInfDefault):
-    return builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
+    builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
 
 def MonsterAddInfinityDefault(builder, infinityDefault):
-    return builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
+    builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
 
 def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault):
-    return builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
+    builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
 
 def MonsterAddNegativeInfDefault(builder, negativeInfDefault):
-    return builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
+    builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
 
 def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault):
-    return builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
+    builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
 
 def MonsterAddDoubleInfDefault(builder, doubleInfDefault):
-    return builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
+    builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
 
 def MonsterEnd(builder):
     return builder.EndObject()
@@ -2652,46 +2652,46 @@ class TypeAliases(object):
         return o == 0
 
 def TypeAliasesStart(builder):
-    return builder.StartObject(12)
+    builder.StartObject(12)
 
 def TypeAliasesAddI8(builder, i8):
-    return builder.PrependInt8Slot(0, i8, 0)
+    builder.PrependInt8Slot(0, i8, 0)
 
 def TypeAliasesAddU8(builder, u8):
-    return builder.PrependUint8Slot(1, u8, 0)
+    builder.PrependUint8Slot(1, u8, 0)
 
 def TypeAliasesAddI16(builder, i16):
-    return builder.PrependInt16Slot(2, i16, 0)
+    builder.PrependInt16Slot(2, i16, 0)
 
 def TypeAliasesAddU16(builder, u16):
-    return builder.PrependUint16Slot(3, u16, 0)
+    builder.PrependUint16Slot(3, u16, 0)
 
 def TypeAliasesAddI32(builder, i32):
-    return builder.PrependInt32Slot(4, i32, 0)
+    builder.PrependInt32Slot(4, i32, 0)
 
 def TypeAliasesAddU32(builder, u32):
-    return builder.PrependUint32Slot(5, u32, 0)
+    builder.PrependUint32Slot(5, u32, 0)
 
 def TypeAliasesAddI64(builder, i64):
-    return builder.PrependInt64Slot(6, i64, 0)
+    builder.PrependInt64Slot(6, i64, 0)
 
 def TypeAliasesAddU64(builder, u64):
-    return builder.PrependUint64Slot(7, u64, 0)
+    builder.PrependUint64Slot(7, u64, 0)
 
 def TypeAliasesAddF32(builder, f32):
-    return builder.PrependFloat32Slot(8, f32, 0.0)
+    builder.PrependFloat32Slot(8, f32, 0.0)
 
 def TypeAliasesAddF64(builder, f64):
-    return builder.PrependFloat64Slot(9, f64, 0.0)
+    builder.PrependFloat64Slot(9, f64, 0.0)
 
 def TypeAliasesAddV8(builder, v8):
-    return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
 
 def TypeAliasesStartV8Vector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
 def TypeAliasesAddVf64(builder, vf64):
-    return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
 
 def TypeAliasesStartVf64Vector(builder, numElems):
     return builder.StartVector(8, numElems, 8)

tests/optional_scalars/ScalarStuff.py

@@ -281,226 +281,226 @@ class ScalarStuff(object):
         return 1
 
 def ScalarStuffStart(builder):
-    return builder.StartObject(36)
+    builder.StartObject(36)
 
 def Start(builder):
-    return ScalarStuffStart(builder)
+    ScalarStuffStart(builder)
 
 def ScalarStuffAddJustI8(builder, justI8):
-    return builder.PrependInt8Slot(0, justI8, 0)
+    builder.PrependInt8Slot(0, justI8, 0)
 
-def AddJustI8(builder, justI8):
+def AddJustI8(builder: flatbuffers.Builder, justI8: int):
-    return ScalarStuffAddJustI8(builder, justI8)
+    ScalarStuffAddJustI8(builder, justI8)
 
 def ScalarStuffAddMaybeI8(builder, maybeI8):
-    return builder.PrependInt8Slot(1, maybeI8, None)
+    builder.PrependInt8Slot(1, maybeI8, None)
 
-def AddMaybeI8(builder, maybeI8):
+def AddMaybeI8(builder: flatbuffers.Builder, maybeI8: int):
-    return ScalarStuffAddMaybeI8(builder, maybeI8)
+    ScalarStuffAddMaybeI8(builder, maybeI8)
 
 def ScalarStuffAddDefaultI8(builder, defaultI8):
-    return builder.PrependInt8Slot(2, defaultI8, 42)
+    builder.PrependInt8Slot(2, defaultI8, 42)
 
-def AddDefaultI8(builder, defaultI8):
+def AddDefaultI8(builder: flatbuffers.Builder, defaultI8: int):
-    return ScalarStuffAddDefaultI8(builder, defaultI8)
+    ScalarStuffAddDefaultI8(builder, defaultI8)
 
 def ScalarStuffAddJustU8(builder, justU8):
-    return builder.PrependUint8Slot(3, justU8, 0)
+    builder.PrependUint8Slot(3, justU8, 0)
 
-def AddJustU8(builder, justU8):
+def AddJustU8(builder: flatbuffers.Builder, justU8: int):
-    return ScalarStuffAddJustU8(builder, justU8)
+    ScalarStuffAddJustU8(builder, justU8)
 
 def ScalarStuffAddMaybeU8(builder, maybeU8):
-    return builder.PrependUint8Slot(4, maybeU8, None)
+    builder.PrependUint8Slot(4, maybeU8, None)
 
-def AddMaybeU8(builder, maybeU8):
+def AddMaybeU8(builder: flatbuffers.Builder, maybeU8: int):
-    return ScalarStuffAddMaybeU8(builder, maybeU8)
+    ScalarStuffAddMaybeU8(builder, maybeU8)
 
 def ScalarStuffAddDefaultU8(builder, defaultU8):
-    return builder.PrependUint8Slot(5, defaultU8, 42)
+    builder.PrependUint8Slot(5, defaultU8, 42)
 
-def AddDefaultU8(builder, defaultU8):
+def AddDefaultU8(builder: flatbuffers.Builder, defaultU8: int):
-    return ScalarStuffAddDefaultU8(builder, defaultU8)
+    ScalarStuffAddDefaultU8(builder, defaultU8)
 
 def ScalarStuffAddJustI16(builder, justI16):
-    return builder.PrependInt16Slot(6, justI16, 0)
+    builder.PrependInt16Slot(6, justI16, 0)
 
-def AddJustI16(builder, justI16):
+def AddJustI16(builder: flatbuffers.Builder, justI16: int):
-    return ScalarStuffAddJustI16(builder, justI16)
+    ScalarStuffAddJustI16(builder, justI16)
 
 def ScalarStuffAddMaybeI16(builder, maybeI16):
-    return builder.PrependInt16Slot(7, maybeI16, None)
+    builder.PrependInt16Slot(7, maybeI16, None)
 
-def AddMaybeI16(builder, maybeI16):
+def AddMaybeI16(builder: flatbuffers.Builder, maybeI16: int):
-    return ScalarStuffAddMaybeI16(builder, maybeI16)
+    ScalarStuffAddMaybeI16(builder, maybeI16)
 
 def ScalarStuffAddDefaultI16(builder, defaultI16):
-    return builder.PrependInt16Slot(8, defaultI16, 42)
+    builder.PrependInt16Slot(8, defaultI16, 42)
 
-def AddDefaultI16(builder, defaultI16):
+def AddDefaultI16(builder: flatbuffers.Builder, defaultI16: int):
-    return ScalarStuffAddDefaultI16(builder, defaultI16)
+    ScalarStuffAddDefaultI16(builder, defaultI16)
 
 def ScalarStuffAddJustU16(builder, justU16):
-    return builder.PrependUint16Slot(9, justU16, 0)
+    builder.PrependUint16Slot(9, justU16, 0)
 
-def AddJustU16(builder, justU16):
+def AddJustU16(builder: flatbuffers.Builder, justU16: int):
-    return ScalarStuffAddJustU16(builder, justU16)
+    ScalarStuffAddJustU16(builder, justU16)
 
 def ScalarStuffAddMaybeU16(builder, maybeU16):
-    return builder.PrependUint16Slot(10, maybeU16, None)
+    builder.PrependUint16Slot(10, maybeU16, None)
 
-def AddMaybeU16(builder, maybeU16):
+def AddMaybeU16(builder: flatbuffers.Builder, maybeU16: int):
-    return ScalarStuffAddMaybeU16(builder, maybeU16)
+    ScalarStuffAddMaybeU16(builder, maybeU16)
 
 def ScalarStuffAddDefaultU16(builder, defaultU16):
-    return builder.PrependUint16Slot(11, defaultU16, 42)
+    builder.PrependUint16Slot(11, defaultU16, 42)
 
-def AddDefaultU16(builder, defaultU16):
+def AddDefaultU16(builder: flatbuffers.Builder, defaultU16: int):
-    return ScalarStuffAddDefaultU16(builder, defaultU16)
+    ScalarStuffAddDefaultU16(builder, defaultU16)
 
 def ScalarStuffAddJustI32(builder, justI32):
-    return builder.PrependInt32Slot(12, justI32, 0)
+    builder.PrependInt32Slot(12, justI32, 0)
 
-def AddJustI32(builder, justI32):
+def AddJustI32(builder: flatbuffers.Builder, justI32: int):
-    return ScalarStuffAddJustI32(builder, justI32)
+    ScalarStuffAddJustI32(builder, justI32)
 
 def ScalarStuffAddMaybeI32(builder, maybeI32):
-    return builder.PrependInt32Slot(13, maybeI32, None)
+    builder.PrependInt32Slot(13, maybeI32, None)
 
-def AddMaybeI32(builder, maybeI32):
+def AddMaybeI32(builder: flatbuffers.Builder, maybeI32: int):
-    return ScalarStuffAddMaybeI32(builder, maybeI32)
+    ScalarStuffAddMaybeI32(builder, maybeI32)
 
 def ScalarStuffAddDefaultI32(builder, defaultI32):
-    return builder.PrependInt32Slot(14, defaultI32, 42)
+    builder.PrependInt32Slot(14, defaultI32, 42)
 
-def AddDefaultI32(builder, defaultI32):
+def AddDefaultI32(builder: flatbuffers.Builder, defaultI32: int):
-    return ScalarStuffAddDefaultI32(builder, defaultI32)
+    ScalarStuffAddDefaultI32(builder, defaultI32)
 
 def ScalarStuffAddJustU32(builder, justU32):
-    return builder.PrependUint32Slot(15, justU32, 0)
+    builder.PrependUint32Slot(15, justU32, 0)
 
-def AddJustU32(builder, justU32):
+def AddJustU32(builder: flatbuffers.Builder, justU32: int):
-    return ScalarStuffAddJustU32(builder, justU32)
+    ScalarStuffAddJustU32(builder, justU32)
 
 def ScalarStuffAddMaybeU32(builder, maybeU32):
-    return builder.PrependUint32Slot(16, maybeU32, None)
+    builder.PrependUint32Slot(16, maybeU32, None)
 
-def AddMaybeU32(builder, maybeU32):
+def AddMaybeU32(builder: flatbuffers.Builder, maybeU32: int):
-    return ScalarStuffAddMaybeU32(builder, maybeU32)
+    ScalarStuffAddMaybeU32(builder, maybeU32)
 
 def ScalarStuffAddDefaultU32(builder, defaultU32):
-    return builder.PrependUint32Slot(17, defaultU32, 42)
+    builder.PrependUint32Slot(17, defaultU32, 42)
 
-def AddDefaultU32(builder, defaultU32):
+def AddDefaultU32(builder: flatbuffers.Builder, defaultU32: int):
-    return ScalarStuffAddDefaultU32(builder, defaultU32)
+    ScalarStuffAddDefaultU32(builder, defaultU32)
 
 def ScalarStuffAddJustI64(builder, justI64):
-    return builder.PrependInt64Slot(18, justI64, 0)
+    builder.PrependInt64Slot(18, justI64, 0)
 
-def AddJustI64(builder, justI64):
+def AddJustI64(builder: flatbuffers.Builder, justI64: int):
-    return ScalarStuffAddJustI64(builder, justI64)
+    ScalarStuffAddJustI64(builder, justI64)
 
 def ScalarStuffAddMaybeI64(builder, maybeI64):
-    return builder.PrependInt64Slot(19, maybeI64, None)
+    builder.PrependInt64Slot(19, maybeI64, None)
 
-def AddMaybeI64(builder, maybeI64):
+def AddMaybeI64(builder: flatbuffers.Builder, maybeI64: int):
-    return ScalarStuffAddMaybeI64(builder, maybeI64)
+    ScalarStuffAddMaybeI64(builder, maybeI64)
 
 def ScalarStuffAddDefaultI64(builder, defaultI64):
-    return builder.PrependInt64Slot(20, defaultI64, 42)
+    builder.PrependInt64Slot(20, defaultI64, 42)
 
-def AddDefaultI64(builder, defaultI64):
+def AddDefaultI64(builder: flatbuffers.Builder, defaultI64: int):
-    return ScalarStuffAddDefaultI64(builder, defaultI64)
+    ScalarStuffAddDefaultI64(builder, defaultI64)
 
 def ScalarStuffAddJustU64(builder, justU64):
-    return builder.PrependUint64Slot(21, justU64, 0)
+    builder.PrependUint64Slot(21, justU64, 0)
 
-def AddJustU64(builder, justU64):
+def AddJustU64(builder: flatbuffers.Builder, justU64: int):
-    return ScalarStuffAddJustU64(builder, justU64)
+    ScalarStuffAddJustU64(builder, justU64)
 
 def ScalarStuffAddMaybeU64(builder, maybeU64):
-    return builder.PrependUint64Slot(22, maybeU64, None)
+    builder.PrependUint64Slot(22, maybeU64, None)
 
-def AddMaybeU64(builder, maybeU64):
+def AddMaybeU64(builder: flatbuffers.Builder, maybeU64: int):
-    return ScalarStuffAddMaybeU64(builder, maybeU64)
+    ScalarStuffAddMaybeU64(builder, maybeU64)
 
 def ScalarStuffAddDefaultU64(builder, defaultU64):
-    return builder.PrependUint64Slot(23, defaultU64, 42)
+    builder.PrependUint64Slot(23, defaultU64, 42)
 
-def AddDefaultU64(builder, defaultU64):
+def AddDefaultU64(builder: flatbuffers.Builder, defaultU64: int):
-    return ScalarStuffAddDefaultU64(builder, defaultU64)
+    ScalarStuffAddDefaultU64(builder, defaultU64)
 
 def ScalarStuffAddJustF32(builder, justF32):
-    return builder.PrependFloat32Slot(24, justF32, 0.0)
+    builder.PrependFloat32Slot(24, justF32, 0.0)
 
-def AddJustF32(builder, justF32):
+def AddJustF32(builder: flatbuffers.Builder, justF32: float):
-    return ScalarStuffAddJustF32(builder, justF32)
+    ScalarStuffAddJustF32(builder, justF32)
 
 def ScalarStuffAddMaybeF32(builder, maybeF32):
-    return builder.PrependFloat32Slot(25, maybeF32, None)
+    builder.PrependFloat32Slot(25, maybeF32, None)
 
-def AddMaybeF32(builder, maybeF32):
+def AddMaybeF32(builder: flatbuffers.Builder, maybeF32: float):
-    return ScalarStuffAddMaybeF32(builder, maybeF32)
+    ScalarStuffAddMaybeF32(builder, maybeF32)
 
 def ScalarStuffAddDefaultF32(builder, defaultF32):
-    return builder.PrependFloat32Slot(26, defaultF32, 42.0)
+    builder.PrependFloat32Slot(26, defaultF32, 42.0)
 
-def AddDefaultF32(builder, defaultF32):
+def AddDefaultF32(builder: flatbuffers.Builder, defaultF32: float):
-    return ScalarStuffAddDefaultF32(builder, defaultF32)
+    ScalarStuffAddDefaultF32(builder, defaultF32)
 
 def ScalarStuffAddJustF64(builder, justF64):
-    return builder.PrependFloat64Slot(27, justF64, 0.0)
+    builder.PrependFloat64Slot(27, justF64, 0.0)
 
-def AddJustF64(builder, justF64):
+def AddJustF64(builder: flatbuffers.Builder, justF64: float):
-    return ScalarStuffAddJustF64(builder, justF64)
+    ScalarStuffAddJustF64(builder, justF64)
 
 def ScalarStuffAddMaybeF64(builder, maybeF64):
-    return builder.PrependFloat64Slot(28, maybeF64, None)
+    builder.PrependFloat64Slot(28, maybeF64, None)
 
-def AddMaybeF64(builder, maybeF64):
+def AddMaybeF64(builder: flatbuffers.Builder, maybeF64: float):
-    return ScalarStuffAddMaybeF64(builder, maybeF64)
+    ScalarStuffAddMaybeF64(builder, maybeF64)
 
 def ScalarStuffAddDefaultF64(builder, defaultF64):
-    return builder.PrependFloat64Slot(29, defaultF64, 42.0)
+    builder.PrependFloat64Slot(29, defaultF64, 42.0)
 
-def AddDefaultF64(builder, defaultF64):
+def AddDefaultF64(builder: flatbuffers.Builder, defaultF64: float):
-    return ScalarStuffAddDefaultF64(builder, defaultF64)
+    ScalarStuffAddDefaultF64(builder, defaultF64)
 
 def ScalarStuffAddJustBool(builder, justBool):
-    return builder.PrependBoolSlot(30, justBool, 0)
+    builder.PrependBoolSlot(30, justBool, 0)
 
-def AddJustBool(builder, justBool):
+def AddJustBool(builder: flatbuffers.Builder, justBool: bool):
-    return ScalarStuffAddJustBool(builder, justBool)
+    ScalarStuffAddJustBool(builder, justBool)
 
 def ScalarStuffAddMaybeBool(builder, maybeBool):
-    return builder.PrependBoolSlot(31, maybeBool, None)
+    builder.PrependBoolSlot(31, maybeBool, None)
 
-def AddMaybeBool(builder, maybeBool):
+def AddMaybeBool(builder: flatbuffers.Builder, maybeBool: bool):
-    return ScalarStuffAddMaybeBool(builder, maybeBool)
+    ScalarStuffAddMaybeBool(builder, maybeBool)
 
 def ScalarStuffAddDefaultBool(builder, defaultBool):
-    return builder.PrependBoolSlot(32, defaultBool, 1)
+    builder.PrependBoolSlot(32, defaultBool, 1)
 
-def AddDefaultBool(builder, defaultBool):
+def AddDefaultBool(builder: flatbuffers.Builder, defaultBool: bool):
-    return ScalarStuffAddDefaultBool(builder, defaultBool)
+    ScalarStuffAddDefaultBool(builder, defaultBool)
 
 def ScalarStuffAddJustEnum(builder, justEnum):
-    return builder.PrependInt8Slot(33, justEnum, 0)
+    builder.PrependInt8Slot(33, justEnum, 0)
 
-def AddJustEnum(builder, justEnum):
+def AddJustEnum(builder: flatbuffers.Builder, justEnum: int):
-    return ScalarStuffAddJustEnum(builder, justEnum)
+    ScalarStuffAddJustEnum(builder, justEnum)
 
 def ScalarStuffAddMaybeEnum(builder, maybeEnum):
-    return builder.PrependInt8Slot(34, maybeEnum, None)
+    builder.PrependInt8Slot(34, maybeEnum, None)
 
-def AddMaybeEnum(builder, maybeEnum):
+def AddMaybeEnum(builder: flatbuffers.Builder, maybeEnum: int):
-    return ScalarStuffAddMaybeEnum(builder, maybeEnum)
+    ScalarStuffAddMaybeEnum(builder, maybeEnum)
 
 def ScalarStuffAddDefaultEnum(builder, defaultEnum):
-    return builder.PrependInt8Slot(35, defaultEnum, 1)
+    builder.PrependInt8Slot(35, defaultEnum, 1)
 
-def AddDefaultEnum(builder, defaultEnum):
+def AddDefaultEnum(builder: flatbuffers.Builder, defaultEnum: int):
-    return ScalarStuffAddDefaultEnum(builder, defaultEnum)
+    ScalarStuffAddDefaultEnum(builder, defaultEnum)
 
 def ScalarStuffEnd(builder):
     return builder.EndObject()

tests/test.fbs

@@ -0,0 +1,85 @@
+// Generated from test.proto
+
+include "imported.fbs";
+
+namespace proto.test;
+
+/// Enum doc comment.
+enum ProtoEnum : int {
+  NUL = 0,
+  FOO = 1,
+  /// Enum 2nd value doc comment misaligned.
+  BAR = 5,
+}
+
+namespace proto.test.ProtoMessage_.OtherMessage_;
+
+enum ProtoEnum : int {
+  NUL = 0,
+  FOO = 1,
+  BAR = 2,
+  BAZ = 3,
+}
+
+namespace proto.test;
+
+/// 2nd table doc comment with
+/// many lines.
+table ProtoMessage {
+  c:int = 16;
+  d:long;
+  p:uint;
+  e:ulong;
+  /// doc comment for f.
+  f:int = -1;
+  g:long;
+  h:uint;
+  q:ulong;
+  i:int;
+  j:long;
+  /// doc comment for k.
+  k:bool;
+  /// doc comment for l on 2
+  /// lines
+  l:string (required);
+  m:[ubyte];
+  n:proto.test.ProtoMessage_.OtherMessage;
+  o:[string];
+  z:proto.test.ImportedMessage;
+  /// doc comment for r.
+  r:proto.test.ProtoMessage_.Anonymous0;
+  outer_enum:proto.test.ProtoEnum;
+  u:float = +inf;
+  v:float = +inf;
+  w:float = -inf;
+  grades:[proto.test.ProtoMessage_.GradesEntry];
+  other_message_map:[proto.test.ProtoMessage_.OtherMessageMapEntry];
+}
+
+namespace proto.test.ProtoMessage_;
+
+table OtherMessage {
+  a:double;
+  /// doc comment for b.
+  b:float = 3.14149;
+  foo_bar_baz:proto.test.ProtoMessage_.OtherMessage_.ProtoEnum;
+}
+
+table Anonymous0 {
+  /// doc comment for s.
+  s:proto.test.ImportedMessage;
+  /// doc comment for t on 2
+  /// lines.
+  t:proto.test.ProtoMessage_.OtherMessage;
+}
+
+table GradesEntry {
+  key:string (key);
+  value:float;
+}
+
+table OtherMessageMapEntry {
+  key:string (key);
+  value:proto.test.ProtoMessage_.OtherMessage;
+}
+