GitHub/flatbuffers
1
0
Fork 0
mirror of https://github.com/google/flatbuffers.git synced 2025-04-08 09:12:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Optionally generate Python type annotations (#7858)

Browse Source 
* 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
This commit is contained in:
Max Burke 2023-04-28 09:38:29 -07:00 committed by GitHub
parent 6eae49a79a
commit a397dd7e8c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
35 changed files with 1295 additions and 979 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
grpc/examples/python/greeter/models/HelloReply.py
View File

@ -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):
return HelloReplyAddMessage(builder, message)
def AddMessage(builder: flatbuffers.Builder, message: int):
HelloReplyAddMessage(builder, message)
def HelloReplyEnd(builder):
return builder.EndObject()

10
grpc/examples/python/greeter/models/HelloRequest.py
View File

@ -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):
return HelloRequestAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
HelloRequestAddName(builder, name)
def HelloRequestEnd(builder):
return builder.EndObject()

2
include/flatbuffers/idl.h
View File

@ -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),

58
python/flatbuffers/reflection/Enum.py
View File

@ -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):
return EnumAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
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):
return EnumAddValues(builder, values)
def AddValues(builder: flatbuffers.Builder, values: int):
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):
return EnumAddIsUnion(builder, isUnion)
def AddIsUnion(builder: flatbuffers.Builder, isUnion: bool):
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):
return EnumAddUnderlyingType(builder, underlyingType)
def AddUnderlyingType(builder: flatbuffers.Builder, underlyingType: int):
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):
return EnumAddAttributes(builder, attributes)
def AddAttributes(builder: flatbuffers.Builder, attributes: int):
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):
return EnumAddDocumentation(builder, documentation)
def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
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):
return EnumAddDeclarationFile(builder, declarationFile)
def AddDeclarationFile(builder: flatbuffers.Builder, declarationFile: int):
EnumAddDeclarationFile(builder, declarationFile)
def EnumEnd(builder):
return builder.EndObject()

42
python/flatbuffers/reflection/EnumVal.py
View File

@ -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):
return EnumValAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
EnumValAddName(builder, name)
def EnumValAddValue(builder, value):
return builder.PrependInt64Slot(1, value, 0)
builder.PrependInt64Slot(1, value, 0)
def AddValue(builder, value):
return EnumValAddValue(builder, value)
def AddValue(builder: flatbuffers.Builder, value: int):
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):
return EnumValAddUnionType(builder, unionType)
def AddUnionType(builder: flatbuffers.Builder, unionType: int):
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):
return EnumValAddDocumentation(builder, documentation)
def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
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):
return EnumValAddAttributes(builder, attributes)
def AddAttributes(builder: flatbuffers.Builder, attributes: int):
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):

90
python/flatbuffers/reflection/Field.py
View File

@ -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):
return FieldAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
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):
return FieldAddType(builder, type)
def AddType(builder: flatbuffers.Builder, type: int):
FieldAddType(builder, type)
def FieldAddId(builder, id):
return builder.PrependUint16Slot(2, id, 0)
builder.PrependUint16Slot(2, id, 0)
def AddId(builder, id):
return FieldAddId(builder, id)
def AddId(builder: flatbuffers.Builder, id: int):
FieldAddId(builder, id)
def FieldAddOffset(builder, offset):
return builder.PrependUint16Slot(3, offset, 0)
builder.PrependUint16Slot(3, offset, 0)
def AddOffset(builder, offset):
return FieldAddOffset(builder, offset)
def AddOffset(builder: flatbuffers.Builder, offset: int):
FieldAddOffset(builder, offset)
def FieldAddDefaultInteger(builder, defaultInteger):
return builder.PrependInt64Slot(4, defaultInteger, 0)
builder.PrependInt64Slot(4, defaultInteger, 0)
def AddDefaultInteger(builder, defaultInteger):
return FieldAddDefaultInteger(builder, defaultInteger)
def AddDefaultInteger(builder: flatbuffers.Builder, defaultInteger: int):
FieldAddDefaultInteger(builder, defaultInteger)
def FieldAddDefaultReal(builder, defaultReal):
return builder.PrependFloat64Slot(5, defaultReal, 0.0)
builder.PrependFloat64Slot(5, defaultReal, 0.0)
def AddDefaultReal(builder, defaultReal):
return FieldAddDefaultReal(builder, defaultReal)
def AddDefaultReal(builder: flatbuffers.Builder, defaultReal: float):
FieldAddDefaultReal(builder, defaultReal)
def FieldAddDeprecated(builder, deprecated):
return builder.PrependBoolSlot(6, deprecated, 0)
builder.PrependBoolSlot(6, deprecated, 0)
def AddDeprecated(builder, deprecated):
return FieldAddDeprecated(builder, deprecated)
def AddDeprecated(builder: flatbuffers.Builder, deprecated: bool):
FieldAddDeprecated(builder, deprecated)
def FieldAddRequired(builder, required):
return builder.PrependBoolSlot(7, required, 0)
builder.PrependBoolSlot(7, required, 0)
def AddRequired(builder, required):
return FieldAddRequired(builder, required)
def AddRequired(builder: flatbuffers.Builder, required: bool):
FieldAddRequired(builder, required)
def FieldAddKey(builder, key):
return builder.PrependBoolSlot(8, key, 0)
builder.PrependBoolSlot(8, key, 0)
def AddKey(builder, key):
return FieldAddKey(builder, key)
def AddKey(builder: flatbuffers.Builder, key: bool):
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):
return FieldAddAttributes(builder, attributes)
def AddAttributes(builder: flatbuffers.Builder, attributes: int):
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):
return FieldAddDocumentation(builder, documentation)
def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
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):
return FieldAddOptional(builder, optional)
def AddOptional(builder: flatbuffers.Builder, optional: bool):
FieldAddOptional(builder, optional)
def FieldAddPadding(builder, padding):
return builder.PrependUint16Slot(12, padding, 0)
builder.PrependUint16Slot(12, padding, 0)
def AddPadding(builder, padding):
return FieldAddPadding(builder, padding)
def AddPadding(builder: flatbuffers.Builder, padding: int):
FieldAddPadding(builder, padding)
def FieldEnd(builder):
return builder.EndObject()

16
python/flatbuffers/reflection/KeyValue.py
View File

@ -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):
return KeyValueAddKey(builder, key)
def AddKey(builder: flatbuffers.Builder, key: int):
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):
return KeyValueAddValue(builder, value)
def AddValue(builder: flatbuffers.Builder, value: int):
KeyValueAddValue(builder, value)
def KeyValueEnd(builder):
return builder.EndObject()

62
python/flatbuffers/reflection/Object.py
View File

@ -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):
return ObjectAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
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):
return ObjectAddFields(builder, fields)
def AddFields(builder: flatbuffers.Builder, fields: int):
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):
return ObjectAddIsStruct(builder, isStruct)
def AddIsStruct(builder: flatbuffers.Builder, isStruct: bool):
ObjectAddIsStruct(builder, isStruct)
def ObjectAddMinalign(builder, minalign):
return builder.PrependInt32Slot(3, minalign, 0)
builder.PrependInt32Slot(3, minalign, 0)
def AddMinalign(builder, minalign):
return ObjectAddMinalign(builder, minalign)
def AddMinalign(builder: flatbuffers.Builder, minalign: int):
ObjectAddMinalign(builder, minalign)
def ObjectAddBytesize(builder, bytesize):
return builder.PrependInt32Slot(4, bytesize, 0)
builder.PrependInt32Slot(4, bytesize, 0)
def AddBytesize(builder, bytesize):
return ObjectAddBytesize(builder, bytesize)
def AddBytesize(builder: flatbuffers.Builder, bytesize: int):
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):
return ObjectAddAttributes(builder, attributes)
def AddAttributes(builder: flatbuffers.Builder, attributes: int):
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):
return ObjectAddDocumentation(builder, documentation)
def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
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):
return ObjectAddDeclarationFile(builder, declarationFile)
def AddDeclarationFile(builder: flatbuffers.Builder, declarationFile: int):
ObjectAddDeclarationFile(builder, declarationFile)
def ObjectEnd(builder):
return builder.EndObject()

44
python/flatbuffers/reflection/RPCCall.py
View File

@ -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):
return RPCCallAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
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):
return RPCCallAddRequest(builder, request)
def AddRequest(builder: flatbuffers.Builder, request: int):
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):
return RPCCallAddResponse(builder, response)
def AddResponse(builder: flatbuffers.Builder, response: int):
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):
return RPCCallAddAttributes(builder, attributes)
def AddAttributes(builder: flatbuffers.Builder, attributes: int):
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):
return RPCCallAddDocumentation(builder, documentation)
def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
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):

70
python/flatbuffers/reflection/Schema.py
View File

@ -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):
return SchemaAddObjects(builder, objects)
def AddObjects(builder: flatbuffers.Builder, objects: int):
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):
return SchemaAddEnums(builder, enums)
def AddEnums(builder: flatbuffers.Builder, enums: int):
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):
return SchemaAddFileIdent(builder, fileIdent)
def AddFileIdent(builder: flatbuffers.Builder, fileIdent: int):
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):
return SchemaAddFileExt(builder, fileExt)
def AddFileExt(builder: flatbuffers.Builder, fileExt: int):
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):
return SchemaAddRootTable(builder, rootTable)
def AddRootTable(builder: flatbuffers.Builder, rootTable: int):
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):
return SchemaAddServices(builder, services)
def AddServices(builder: flatbuffers.Builder, services: int):
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):
return SchemaAddAdvancedFeatures(builder, advancedFeatures)
def AddAdvancedFeatures(builder: flatbuffers.Builder, advancedFeatures: int):
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):
return SchemaAddFbsFiles(builder, fbsFiles)
def AddFbsFiles(builder: flatbuffers.Builder, fbsFiles: int):
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):

18
python/flatbuffers/reflection/SchemaFile.py
View File

@ -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):
return SchemaFileAddFilename(builder, filename)
def AddFilename(builder: flatbuffers.Builder, filename: int):
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):
return SchemaFileAddIncludedFilenames(builder, includedFilenames)
def AddIncludedFilenames(builder: flatbuffers.Builder, includedFilenames: int):
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):

44
python/flatbuffers/reflection/Service.py
View File

@ -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):
return ServiceAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
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):
return ServiceAddCalls(builder, calls)
def AddCalls(builder: flatbuffers.Builder, calls: int):
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):
return ServiceAddAttributes(builder, attributes)
def AddAttributes(builder: flatbuffers.Builder, attributes: int):
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):
return ServiceAddDocumentation(builder, documentation)
def AddDocumentation(builder: flatbuffers.Builder, documentation: int):
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):
return ServiceAddDeclarationFile(builder, declarationFile)
def AddDeclarationFile(builder: flatbuffers.Builder, declarationFile: int):
ServiceAddDeclarationFile(builder, declarationFile)
def ServiceEnd(builder):
return builder.EndObject()

40
python/flatbuffers/reflection/Type.py
View File

@ -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):
return TypeAddBaseType(builder, baseType)
def AddBaseType(builder: flatbuffers.Builder, baseType: int):
TypeAddBaseType(builder, baseType)
def TypeAddElement(builder, element):
return builder.PrependInt8Slot(1, element, 0)
builder.PrependInt8Slot(1, element, 0)
def AddElement(builder, element):
return TypeAddElement(builder, element)
def AddElement(builder: flatbuffers.Builder, element: int):
TypeAddElement(builder, element)
def TypeAddIndex(builder, index):
return builder.PrependInt32Slot(2, index, -1)
builder.PrependInt32Slot(2, index, -1)
def AddIndex(builder, index):
return TypeAddIndex(builder, index)
def AddIndex(builder: flatbuffers.Builder, index: int):
TypeAddIndex(builder, index)
def TypeAddFixedLength(builder, fixedLength):
return builder.PrependUint16Slot(3, fixedLength, 0)
builder.PrependUint16Slot(3, fixedLength, 0)
def AddFixedLength(builder, fixedLength):
return TypeAddFixedLength(builder, fixedLength)
def AddFixedLength(builder: flatbuffers.Builder, fixedLength: int):
TypeAddFixedLength(builder, fixedLength)
def TypeAddBaseSize(builder, baseSize):
return builder.PrependUint32Slot(4, baseSize, 4)
builder.PrependUint32Slot(4, baseSize, 4)
def AddBaseSize(builder, baseSize):
return TypeAddBaseSize(builder, baseSize)
def AddBaseSize(builder: flatbuffers.Builder, baseSize: int):
TypeAddBaseSize(builder, baseSize)
def TypeAddElementSize(builder, elementSize):
return builder.PrependUint32Slot(5, elementSize, 0)
builder.PrependUint32Slot(5, elementSize, 0)
def AddElementSize(builder, elementSize):
return TypeAddElementSize(builder, elementSize)
def AddElementSize(builder: flatbuffers.Builder, elementSize: int):
TypeAddElementSize(builder, elementSize)
def TypeEnd(builder):
return builder.EndObject()

0
python/py.typed Normal file
View File

2
scripts/generate_code.py
View File

@ -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"]

4
src/flatc.cpp
View File

@ -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"},
};
@ -654,6 +656,8 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc,
opts.no_leak_private_annotations = true;
} else if (arg == "--python-no-type-prefix-suffix") {
opts.python_no_type_prefix_suffix = true;
} 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") {

350
src/idl_gen_python.cpp
View File

@ -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";
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);
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 += "):";
code += namer_.Method(field) + "Length(self)";
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 += "):";
code += namer_.Method(field) + "IsNone(self)";
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) {
code += GenIndents(2);
code += "from " + GenPackageReference(field.value.type) + " import " +
TypeName(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, 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 += "(self):";
code += namer_.Method(field) + "(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 " +
TypeName(field) + "\n";
code += "from " + import_entry.first + " import " + import_entry.second +
"\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);
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:
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) {
if (!parser_.opts.python_typing) {
code += Indent + Indent + Indent;
code += "from " + GenPackageReference(field.value.type) + " import " +
TypeName(field) + "\n";
code += "from " + import_entry.first + " import " + import_entry.second +
"\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,
std::string *code_ptr) const {
const FieldDef &field, std::string *code_ptr,
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 " +
TypeName(field) + "\n";
code += "from " + import_entry.first + " import " + import_entry.second +
"\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,
std::string *code_ptr) const {
const FieldDef &field, std::string *code_ptr,
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);
if (!parser_.opts.python_typing) {
code += Indent + Indent + Indent;
code += "from " + qualified_name + " import " + unqualified_name + "\n";
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 += Indent + "return builder.StartObject(";
code += "def " + name;
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.
if (parser_.opts.python_typing) {
code += "def Start(builder: flatbuffers.Builder):\n";
} else {
code += "def Start(builder):\n";
code += Indent + "return " + struct_type + "Start(builder)\n\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, ";
code += field_var;
if (parser_.opts.python_typing) {
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;
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.
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.
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";
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_,
one_file_code, true);
return SaveType(mod + ".py", *parser_.current_namespace_, one_file_code,
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) {
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 =

21
tests/MyGame/Example/ArrayStruct.py
View File

@ -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):
from MyGame.Example.NestedStruct import NestedStruct
def D(self, i: int) -> 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

30
tests/MyGame/Example/ArrayTable.py
View File

@ -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):
return builder.StartObject(1)
def ArrayTableStart(builder: flatbuffers.Builder):
builder.StartObject(1)
def Start(builder):
return ArrayTableStart(builder)
def Start(builder: flatbuffers.Builder):
ArrayTableStart(builder)
def ArrayTableAddA(builder, a):
return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
def ArrayTableAddA(builder: flatbuffers.Builder, a: Any):
builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
def AddA(builder, a):
return ArrayTableAddA(builder, a)
def AddA(builder: flatbuffers.Builder, a: Any):
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

438
tests/MyGame/Example/Monster.py
View File

@ -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):
return MonsterAddPos(builder, pos)
def AddPos(builder: flatbuffers.Builder, pos: Any):
MonsterAddPos(builder, pos)
def MonsterAddMana(builder, mana):
return builder.PrependInt16Slot(1, mana, 150)
builder.PrependInt16Slot(1, mana, 150)
def AddMana(builder, mana):
return MonsterAddMana(builder, mana)
def AddMana(builder: flatbuffers.Builder, mana: int):
MonsterAddMana(builder, mana)
def MonsterAddHp(builder, hp):
return builder.PrependInt16Slot(2, hp, 100)
builder.PrependInt16Slot(2, hp, 100)
def AddHp(builder, hp):
return MonsterAddHp(builder, hp)
def AddHp(builder: flatbuffers.Builder, hp: int):
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):
return MonsterAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
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):
return MonsterAddInventory(builder, inventory)
def AddInventory(builder: flatbuffers.Builder, inventory: int):
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):
return MonsterAddColor(builder, color)
def AddColor(builder: flatbuffers.Builder, color: int):
MonsterAddColor(builder, color)
def MonsterAddTestType(builder, testType):
return builder.PrependUint8Slot(7, testType, 0)
builder.PrependUint8Slot(7, testType, 0)
def AddTestType(builder, testType):
return MonsterAddTestType(builder, testType)
def AddTestType(builder: flatbuffers.Builder, testType: int):
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):
return MonsterAddTest(builder, test)
def AddTest(builder: flatbuffers.Builder, test: int):
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):
return MonsterAddTest4(builder, test4)
def AddTest4(builder: flatbuffers.Builder, test4: int):
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):
return MonsterAddTestarrayofstring(builder, testarrayofstring)
def AddTestarrayofstring(builder: flatbuffers.Builder, testarrayofstring: int):
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):
return MonsterAddTestarrayoftables(builder, testarrayoftables)
def AddTestarrayoftables(builder: flatbuffers.Builder, testarrayoftables: int):
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):
return MonsterAddEnemy(builder, enemy)
def AddEnemy(builder: flatbuffers.Builder, enemy: int):
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):
return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
def AddTestnestedflatbuffer(builder: flatbuffers.Builder, testnestedflatbuffer: int):
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):
return MonsterAddTestempty(builder, testempty)
def AddTestempty(builder: flatbuffers.Builder, testempty: int):
MonsterAddTestempty(builder, testempty)
def MonsterAddTestbool(builder, testbool):
return builder.PrependBoolSlot(15, testbool, 0)
builder.PrependBoolSlot(15, testbool, 0)
def AddTestbool(builder, testbool):
return MonsterAddTestbool(builder, testbool)
def AddTestbool(builder: flatbuffers.Builder, testbool: bool):
MonsterAddTestbool(builder, testbool)
def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
return builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
def AddTesthashs32Fnv1(builder: flatbuffers.Builder, testhashs32Fnv1: int):
MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
return builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
def AddTesthashu32Fnv1(builder: flatbuffers.Builder, testhashu32Fnv1: int):
MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
return builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
def AddTesthashs64Fnv1(builder: flatbuffers.Builder, testhashs64Fnv1: int):
MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
return builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
def AddTesthashu64Fnv1(builder: flatbuffers.Builder, testhashu64Fnv1: int):
MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
return builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
def AddTesthashs32Fnv1a(builder: flatbuffers.Builder, testhashs32Fnv1a: int):
MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
return builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
def AddTesthashu32Fnv1a(builder: flatbuffers.Builder, testhashu32Fnv1a: int):
MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
return builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
def AddTesthashs64Fnv1a(builder: flatbuffers.Builder, testhashs64Fnv1a: int):
MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
return builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
def AddTesthashu64Fnv1a(builder: flatbuffers.Builder, testhashu64Fnv1a: int):
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):
return MonsterAddTestarrayofbools(builder, testarrayofbools)
def AddTestarrayofbools(builder: flatbuffers.Builder, testarrayofbools: int):
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):
return MonsterAddTestf(builder, testf)
def AddTestf(builder: flatbuffers.Builder, testf: float):
MonsterAddTestf(builder, testf)
def MonsterAddTestf2(builder, testf2):
return builder.PrependFloat32Slot(26, testf2, 3.0)
builder.PrependFloat32Slot(26, testf2, 3.0)
def AddTestf2(builder, testf2):
return MonsterAddTestf2(builder, testf2)
def AddTestf2(builder: flatbuffers.Builder, testf2: float):
MonsterAddTestf2(builder, testf2)
def MonsterAddTestf3(builder, testf3):
return builder.PrependFloat32Slot(27, testf3, 0.0)
builder.PrependFloat32Slot(27, testf3, 0.0)
def AddTestf3(builder, testf3):
return MonsterAddTestf3(builder, testf3)
def AddTestf3(builder: flatbuffers.Builder, testf3: float):
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):
return MonsterAddTestarrayofstring2(builder, testarrayofstring2)
def AddTestarrayofstring2(builder: flatbuffers.Builder, testarrayofstring2: int):
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):
return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
def AddTestarrayofsortedstruct(builder: flatbuffers.Builder, testarrayofsortedstruct: int):
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):
return MonsterAddFlex(builder, flex)
def AddFlex(builder: flatbuffers.Builder, flex: int):
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):
return MonsterAddTest5(builder, test5)
def AddTest5(builder: flatbuffers.Builder, test5: int):
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):
return MonsterAddVectorOfLongs(builder, vectorOfLongs)
def AddVectorOfLongs(builder: flatbuffers.Builder, vectorOfLongs: int):
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):
return MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
def AddVectorOfDoubles(builder: flatbuffers.Builder, vectorOfDoubles: int):
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):
return MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
def AddParentNamespaceTest(builder: flatbuffers.Builder, parentNamespaceTest: int):
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):
return MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
def AddVectorOfReferrables(builder: flatbuffers.Builder, vectorOfReferrables: int):
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):
return MonsterAddSingleWeakReference(builder, singleWeakReference)
def AddSingleWeakReference(builder: flatbuffers.Builder, singleWeakReference: int):
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):
return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
def AddVectorOfWeakReferences(builder: flatbuffers.Builder, vectorOfWeakReferences: int):
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):
return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
def AddVectorOfStrongReferrables(builder: flatbuffers.Builder, vectorOfStrongReferrables: int):
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):
return MonsterAddCoOwningReference(builder, coOwningReference)
def AddCoOwningReference(builder: flatbuffers.Builder, coOwningReference: int):
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):
return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
def AddVectorOfCoOwningReferences(builder: flatbuffers.Builder, vectorOfCoOwningReferences: int):
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):
return MonsterAddNonOwningReference(builder, nonOwningReference)
def AddNonOwningReference(builder: flatbuffers.Builder, nonOwningReference: int):
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):
return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
def AddVectorOfNonOwningReferences(builder: flatbuffers.Builder, vectorOfNonOwningReferences: int):
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):
return MonsterAddAnyUniqueType(builder, anyUniqueType)
def AddAnyUniqueType(builder: flatbuffers.Builder, anyUniqueType: int):
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):
return MonsterAddAnyUnique(builder, anyUnique)
def AddAnyUnique(builder: flatbuffers.Builder, anyUnique: int):
MonsterAddAnyUnique(builder, anyUnique)
def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
return builder.PrependUint8Slot(45, anyAmbiguousType, 0)
builder.PrependUint8Slot(45, anyAmbiguousType, 0)
def AddAnyAmbiguousType(builder, anyAmbiguousType):
return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
def AddAnyAmbiguousType(builder: flatbuffers.Builder, anyAmbiguousType: int):
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):
return MonsterAddAnyAmbiguous(builder, anyAmbiguous)
def AddAnyAmbiguous(builder: flatbuffers.Builder, anyAmbiguous: int):
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):
return MonsterAddVectorOfEnums(builder, vectorOfEnums)
def AddVectorOfEnums(builder: flatbuffers.Builder, vectorOfEnums: int):
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):
return MonsterAddSignedEnum(builder, signedEnum)
def AddSignedEnum(builder: flatbuffers.Builder, signedEnum: int):
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):
return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
def AddTestrequirednestedflatbuffer(builder: flatbuffers.Builder, testrequirednestedflatbuffer: int):
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):
return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
def AddScalarKeySortedTables(builder: flatbuffers.Builder, scalarKeySortedTables: int):
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):
return MonsterAddNativeInline(builder, nativeInline)
def AddNativeInline(builder: flatbuffers.Builder, nativeInline: Any):
MonsterAddNativeInline(builder, nativeInline)
def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
return builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
return MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
def AddLongEnumNonEnumDefault(builder: flatbuffers.Builder, longEnumNonEnumDefault: int):
MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault):
return builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
def AddLongEnumNormalDefault(builder: flatbuffers.Builder, longEnumNormalDefault: int):
MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
def MonsterAddNanDefault(builder, nanDefault):
return builder.PrependFloat32Slot(54, nanDefault, float('nan'))
builder.PrependFloat32Slot(54, nanDefault, float('nan'))
def AddNanDefault(builder, nanDefault):
return MonsterAddNanDefault(builder, nanDefault)
def AddNanDefault(builder: flatbuffers.Builder, nanDefault: float):
MonsterAddNanDefault(builder, nanDefault)
def MonsterAddInfDefault(builder, infDefault):
return builder.PrependFloat32Slot(55, infDefault, float('inf'))
builder.PrependFloat32Slot(55, infDefault, float('inf'))
def AddInfDefault(builder, infDefault):
return MonsterAddInfDefault(builder, infDefault)
def AddInfDefault(builder: flatbuffers.Builder, infDefault: float):
MonsterAddInfDefault(builder, infDefault)
def MonsterAddPositiveInfDefault(builder, positiveInfDefault):
return builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
def AddPositiveInfDefault(builder, positiveInfDefault):
return MonsterAddPositiveInfDefault(builder, positiveInfDefault)
def AddPositiveInfDefault(builder: flatbuffers.Builder, positiveInfDefault: float):
MonsterAddPositiveInfDefault(builder, positiveInfDefault)
def MonsterAddInfinityDefault(builder, infinityDefault):
return builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
def AddInfinityDefault(builder, infinityDefault):
return MonsterAddInfinityDefault(builder, infinityDefault)
def AddInfinityDefault(builder: flatbuffers.Builder, infinityDefault: float):
MonsterAddInfinityDefault(builder, infinityDefault)
def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault):
return builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
return MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
def AddPositiveInfinityDefault(builder: flatbuffers.Builder, positiveInfinityDefault: float):
MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
def MonsterAddNegativeInfDefault(builder, negativeInfDefault):
return builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
def AddNegativeInfDefault(builder, negativeInfDefault):
return MonsterAddNegativeInfDefault(builder, negativeInfDefault)
def AddNegativeInfDefault(builder: flatbuffers.Builder, negativeInfDefault: float):
MonsterAddNegativeInfDefault(builder, negativeInfDefault)
def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault):
return builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
return MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
def AddNegativeInfinityDefault(builder: flatbuffers.Builder, negativeInfinityDefault: float):
MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
def MonsterAddDoubleInfDefault(builder, doubleInfDefault):
return builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
def AddDoubleInfDefault(builder, doubleInfDefault):
return MonsterAddDoubleInfDefault(builder, doubleInfDefault)
def AddDoubleInfDefault(builder: flatbuffers.Builder, doubleInfDefault: float):
MonsterAddDoubleInfDefault(builder, doubleInfDefault)
def MonsterEnd(builder):
return builder.EndObject()

17
tests/MyGame/Example/NestedStruct.py
View File

@ -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

56
tests/MyGame/Example/NestedUnion/NestedUnionTest.py
View File

@ -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):
return builder.StartObject(4)
def NestedUnionTestStart(builder: flatbuffers.Builder):
builder.StartObject(4)
def Start(builder):
return NestedUnionTestStart(builder)
def Start(builder: flatbuffers.Builder):
NestedUnionTestStart(builder)
def NestedUnionTestAddName(builder, name):
return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def NestedUnionTestAddName(builder: flatbuffers.Builder, name: int):
builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def AddName(builder, name):
return NestedUnionTestAddName(builder, name)
def AddName(builder: flatbuffers.Builder, name: int):
NestedUnionTestAddName(builder, name)
def NestedUnionTestAddDataType(builder, dataType):
return builder.PrependUint8Slot(1, dataType, 0)
def NestedUnionTestAddDataType(builder: flatbuffers.Builder, dataType: int):
builder.PrependUint8Slot(1, dataType, 0)
def AddDataType(builder, dataType):
return NestedUnionTestAddDataType(builder, dataType)
def AddDataType(builder: flatbuffers.Builder, dataType: int):
NestedUnionTestAddDataType(builder, dataType)
def NestedUnionTestAddData(builder, data):
return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
def NestedUnionTestAddData(builder: flatbuffers.Builder, data: int):
builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
def AddData(builder, data):
return NestedUnionTestAddData(builder, data)
def AddData(builder: flatbuffers.Builder, data: int):
NestedUnionTestAddData(builder, data)
def NestedUnionTestAddId(builder, id):
return builder.PrependInt16Slot(3, id, 0)
def NestedUnionTestAddId(builder: flatbuffers.Builder, id: int):
builder.PrependInt16Slot(3, id, 0)
def AddId(builder, id):
return NestedUnionTestAddId(builder, id)
def AddId(builder: flatbuffers.Builder, id: int):
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

5
tests/MyGame/Example/NestedUnion/Test.py
View File

@ -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

25
tests/MyGame/Example/NestedUnion/TestSimpleTableWithEnum.py
View File

@ -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):
return builder.StartObject(1)
def TestSimpleTableWithEnumStart(builder: flatbuffers.Builder):
builder.StartObject(1)
def Start(builder):
return TestSimpleTableWithEnumStart(builder)
def Start(builder: flatbuffers.Builder):
TestSimpleTableWithEnumStart(builder)
def TestSimpleTableWithEnumAddColor(builder, color):
return builder.PrependUint8Slot(0, color, 2)
def TestSimpleTableWithEnumAddColor(builder: flatbuffers.Builder, color: int):
builder.PrependUint8Slot(0, color, 2)
def AddColor(builder, color):
return TestSimpleTableWithEnumAddColor(builder, color)
def AddColor(builder: flatbuffers.Builder, color: int):
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)

70
tests/MyGame/Example/NestedUnion/Vec3.py
View File

@ -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):
return builder.StartObject(6)
def Vec3Start(builder: flatbuffers.Builder):
builder.StartObject(6)
def Start(builder):
return Vec3Start(builder)
def Start(builder: flatbuffers.Builder):
Vec3Start(builder)
def Vec3AddX(builder, x):
return builder.PrependFloat64Slot(0, x, 0.0)
def Vec3AddX(builder: flatbuffers.Builder, x: float):
builder.PrependFloat64Slot(0, x, 0.0)
def AddX(builder, x):
return Vec3AddX(builder, x)
def AddX(builder: flatbuffers.Builder, x: float):
Vec3AddX(builder, x)
def Vec3AddY(builder, y):
return builder.PrependFloat64Slot(1, y, 0.0)
def Vec3AddY(builder: flatbuffers.Builder, y: float):
builder.PrependFloat64Slot(1, y, 0.0)
def AddY(builder, y):
return Vec3AddY(builder, y)
def AddY(builder: flatbuffers.Builder, y: float):
Vec3AddY(builder, y)
def Vec3AddZ(builder, z):
return builder.PrependFloat64Slot(2, z, 0.0)
def Vec3AddZ(builder: flatbuffers.Builder, z: float):
builder.PrependFloat64Slot(2, z, 0.0)
def AddZ(builder, z):
return Vec3AddZ(builder, z)
def AddZ(builder: flatbuffers.Builder, z: float):
Vec3AddZ(builder, z)
def Vec3AddTest1(builder, test1):
return builder.PrependFloat64Slot(3, test1, 0.0)
def Vec3AddTest1(builder: flatbuffers.Builder, test1: float):
builder.PrependFloat64Slot(3, test1, 0.0)
def AddTest1(builder, test1):
return Vec3AddTest1(builder, test1)
def AddTest1(builder: flatbuffers.Builder, test1: float):
Vec3AddTest1(builder, test1)
def Vec3AddTest2(builder, test2):
return builder.PrependUint8Slot(4, test2, 0)
def Vec3AddTest2(builder: flatbuffers.Builder, test2: int):
builder.PrependUint8Slot(4, test2, 0)
def AddTest2(builder, test2):
return Vec3AddTest2(builder, test2)
def AddTest2(builder: flatbuffers.Builder, test2: int):
Vec3AddTest2(builder, test2)
def Vec3AddTest3(builder, test3):
return builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(test3), 0)
def Vec3AddTest3(builder: flatbuffers.Builder, test3: Any):
builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(test3), 0)
def AddTest3(builder, test3):
return Vec3AddTest3(builder, test3)
def AddTest3(builder: flatbuffers.Builder, test3: Any):
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

10
tests/MyGame/Example/Referrable.py
View File

@ -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):
return ReferrableAddId(builder, id)
def AddId(builder: flatbuffers.Builder, id: int):
ReferrableAddId(builder, id)
def ReferrableEnd(builder):
return builder.EndObject()

22
tests/MyGame/Example/Stat.py
View File

@ -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):
return StatAddId(builder, id)
def AddId(builder: flatbuffers.Builder, id: int):
StatAddId(builder, id)
def StatAddVal(builder, val):
return builder.PrependInt64Slot(1, val, 0)
builder.PrependInt64Slot(1, val, 0)
def AddVal(builder, val):
return StatAddVal(builder, val)
def AddVal(builder: flatbuffers.Builder, val: int):
StatAddVal(builder, val)
def StatAddCount(builder, count):
return builder.PrependUint16Slot(2, count, 0)
builder.PrependUint16Slot(2, count, 0)
def AddCount(builder, count):
return StatAddCount(builder, count)
def AddCount(builder: flatbuffers.Builder, count: int):
StatAddCount(builder, count)
def StatEnd(builder):
return builder.EndObject()

10
tests/MyGame/Example/TestSimpleTableWithEnum.py
View File

@ -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):
return TestSimpleTableWithEnumAddColor(builder, color)
def AddColor(builder: flatbuffers.Builder, color: int):
TestSimpleTableWithEnumAddColor(builder, color)
def TestSimpleTableWithEnumEnd(builder):
return builder.EndObject()

80
tests/MyGame/Example/TypeAliases.py
View File

@ -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):
return TypeAliasesAddI8(builder, i8)
def AddI8(builder: flatbuffers.Builder, i8: int):
TypeAliasesAddI8(builder, i8)
def TypeAliasesAddU8(builder, u8):
return builder.PrependUint8Slot(1, u8, 0)
builder.PrependUint8Slot(1, u8, 0)
def AddU8(builder, u8):
return TypeAliasesAddU8(builder, u8)
def AddU8(builder: flatbuffers.Builder, u8: int):
TypeAliasesAddU8(builder, u8)
def TypeAliasesAddI16(builder, i16):
return builder.PrependInt16Slot(2, i16, 0)
builder.PrependInt16Slot(2, i16, 0)
def AddI16(builder, i16):
return TypeAliasesAddI16(builder, i16)
def AddI16(builder: flatbuffers.Builder, i16: int):
TypeAliasesAddI16(builder, i16)
def TypeAliasesAddU16(builder, u16):
return builder.PrependUint16Slot(3, u16, 0)
builder.PrependUint16Slot(3, u16, 0)
def AddU16(builder, u16):
return TypeAliasesAddU16(builder, u16)
def AddU16(builder: flatbuffers.Builder, u16: int):
TypeAliasesAddU16(builder, u16)
def TypeAliasesAddI32(builder, i32):
return builder.PrependInt32Slot(4, i32, 0)
builder.PrependInt32Slot(4, i32, 0)
def AddI32(builder, i32):
return TypeAliasesAddI32(builder, i32)
def AddI32(builder: flatbuffers.Builder, i32: int):
TypeAliasesAddI32(builder, i32)
def TypeAliasesAddU32(builder, u32):
return builder.PrependUint32Slot(5, u32, 0)
builder.PrependUint32Slot(5, u32, 0)
def AddU32(builder, u32):
return TypeAliasesAddU32(builder, u32)
def AddU32(builder: flatbuffers.Builder, u32: int):
TypeAliasesAddU32(builder, u32)
def TypeAliasesAddI64(builder, i64):
return builder.PrependInt64Slot(6, i64, 0)
builder.PrependInt64Slot(6, i64, 0)
def AddI64(builder, i64):
return TypeAliasesAddI64(builder, i64)
def AddI64(builder: flatbuffers.Builder, i64: int):
TypeAliasesAddI64(builder, i64)
def TypeAliasesAddU64(builder, u64):
return builder.PrependUint64Slot(7, u64, 0)
builder.PrependUint64Slot(7, u64, 0)
def AddU64(builder, u64):
return TypeAliasesAddU64(builder, u64)
def AddU64(builder: flatbuffers.Builder, u64: int):
TypeAliasesAddU64(builder, u64)
def TypeAliasesAddF32(builder, f32):
return builder.PrependFloat32Slot(8, f32, 0.0)
builder.PrependFloat32Slot(8, f32, 0.0)
def AddF32(builder, f32):
return TypeAliasesAddF32(builder, f32)
def AddF32(builder: flatbuffers.Builder, f32: float):
TypeAliasesAddF32(builder, f32)
def TypeAliasesAddF64(builder, f64):
return builder.PrependFloat64Slot(9, f64, 0.0)
builder.PrependFloat64Slot(9, f64, 0.0)
def AddF64(builder, f64):
return TypeAliasesAddF64(builder, f64)
def AddF64(builder: flatbuffers.Builder, f64: float):
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):
return TypeAliasesAddV8(builder, v8)
def AddV8(builder: flatbuffers.Builder, v8: int):
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):
return TypeAliasesAddVf64(builder, vf64)
def AddVf64(builder: flatbuffers.Builder, vf64: int):
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):

4
tests/MyGame/Example2/Monster.py
View File

@ -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()

4
tests/MyGame/InParentNamespace.py
View File

@ -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()

117
tests/MyGame/MonsterExtra.py
View File

@ -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):
return builder.StartObject(11)
def MonsterExtraStart(builder: flatbuffers.Builder):
builder.StartObject(11)
def Start(builder):
return MonsterExtraStart(builder)
def Start(builder: flatbuffers.Builder):
MonsterExtraStart(builder)
def MonsterExtraAddD0(builder, d0):
return builder.PrependFloat64Slot(0, d0, float('nan'))
def MonsterExtraAddD0(builder: flatbuffers.Builder, d0: float):
builder.PrependFloat64Slot(0, d0, float('nan'))
def AddD0(builder, d0):
return MonsterExtraAddD0(builder, d0)
def AddD0(builder: flatbuffers.Builder, d0: float):
MonsterExtraAddD0(builder, d0)
def MonsterExtraAddD1(builder, d1):
return builder.PrependFloat64Slot(1, d1, float('nan'))
def MonsterExtraAddD1(builder: flatbuffers.Builder, d1: float):
builder.PrependFloat64Slot(1, d1, float('nan'))
def AddD1(builder, d1):
return MonsterExtraAddD1(builder, d1)
def AddD1(builder: flatbuffers.Builder, d1: float):
MonsterExtraAddD1(builder, d1)
def MonsterExtraAddD2(builder, d2):
return builder.PrependFloat64Slot(2, d2, float('inf'))
def MonsterExtraAddD2(builder: flatbuffers.Builder, d2: float):
builder.PrependFloat64Slot(2, d2, float('inf'))
def AddD2(builder, d2):
return MonsterExtraAddD2(builder, d2)
def AddD2(builder: flatbuffers.Builder, d2: float):
MonsterExtraAddD2(builder, d2)
def MonsterExtraAddD3(builder, d3):
return builder.PrependFloat64Slot(3, d3, float('-inf'))
def MonsterExtraAddD3(builder: flatbuffers.Builder, d3: float):
builder.PrependFloat64Slot(3, d3, float('-inf'))
def AddD3(builder, d3):
return MonsterExtraAddD3(builder, d3)
def AddD3(builder: flatbuffers.Builder, d3: float):
MonsterExtraAddD3(builder, d3)
def MonsterExtraAddF0(builder, f0):
return builder.PrependFloat32Slot(4, f0, float('nan'))
def MonsterExtraAddF0(builder: flatbuffers.Builder, f0: float):
builder.PrependFloat32Slot(4, f0, float('nan'))
def AddF0(builder, f0):
return MonsterExtraAddF0(builder, f0)
def AddF0(builder: flatbuffers.Builder, f0: float):
MonsterExtraAddF0(builder, f0)
def MonsterExtraAddF1(builder, f1):
return builder.PrependFloat32Slot(5, f1, float('nan'))
def MonsterExtraAddF1(builder: flatbuffers.Builder, f1: float):
builder.PrependFloat32Slot(5, f1, float('nan'))
def AddF1(builder, f1):
return MonsterExtraAddF1(builder, f1)
def AddF1(builder: flatbuffers.Builder, f1: float):
MonsterExtraAddF1(builder, f1)
def MonsterExtraAddF2(builder, f2):
return builder.PrependFloat32Slot(6, f2, float('inf'))
def MonsterExtraAddF2(builder: flatbuffers.Builder, f2: float):
builder.PrependFloat32Slot(6, f2, float('inf'))
def AddF2(builder, f2):
return MonsterExtraAddF2(builder, f2)
def AddF2(builder: flatbuffers.Builder, f2: float):
MonsterExtraAddF2(builder, f2)
def MonsterExtraAddF3(builder, f3):
return builder.PrependFloat32Slot(7, f3, float('-inf'))
def MonsterExtraAddF3(builder: flatbuffers.Builder, f3: float):
builder.PrependFloat32Slot(7, f3, float('-inf'))
def AddF3(builder, f3):
return MonsterExtraAddF3(builder, f3)
def AddF3(builder: flatbuffers.Builder, f3: float):
MonsterExtraAddF3(builder, f3)
def MonsterExtraAddDvec(builder, dvec):
return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
def MonsterExtraAddDvec(builder: flatbuffers.Builder, dvec: int):
builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
def AddDvec(builder, dvec):
return MonsterExtraAddDvec(builder, dvec)
def AddDvec(builder: flatbuffers.Builder, dvec: int):
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):
return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
def MonsterExtraAddFvec(builder: flatbuffers.Builder, fvec: int):
builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
def AddFvec(builder, fvec):
return MonsterExtraAddFvec(builder, fvec)
def AddFvec(builder: flatbuffers.Builder, fvec: int):
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:

174
tests/monster_test_generated.py
View File

@ -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)

220
tests/optional_scalars/ScalarStuff.py
View File

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

85
tests/test.fbs Normal file
View File

@ -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;
}