BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-07 13:53:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix python tests (#7960)

Browse Source 
* Don't generate types unless --python-typing specified

Fixes https://github.com/google/flatbuffers/issues/7944

* Fix incorrect import statements

Fixes https://github.com/google/flatbuffers/issues/7951

* Fix $PYTHONPATH in PythonTest.sh

Regressed from https://github.com/google/flatbuffers/pull/7529

* PythonTest: fail if something goes wrong

GitHub Actions runs `bash PythonTest.sh`, and thus failures were not
visible.

* Build flatc for Python tests

* Regenerate codes

---------

Co-authored-by: Derek Bailey <derekbailey@google.com>
This commit is contained in:
Chih-Hsuan Yen
2023-05-18 04:10:51 +08:00
committed by GitHub
parent cb14043f82
commit a352bdbc34
25 changed files with 234 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -5,7 +5,7 @@
import flatbuffers
from flatbuffers.compat import import_numpy
from typing import Any
from .MyGame.Example.NestedStruct import NestedStruct
from MyGame.Example.NestedStruct import NestedStruct
np = import_numpy()
class ArrayStruct(object):

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

@@ -5,7 +5,7 @@
import flatbuffers
from flatbuffers.compat import import_numpy
from typing import Any
from .MyGame.Example.ArrayStruct import ArrayStruct
from MyGame.Example.ArrayStruct import ArrayStruct
from typing import Optional
np = import_numpy()

150
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
@@ -881,31 +881,31 @@ def Start(builder):
def MonsterAddPos(builder, pos):
builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
def AddPos(builder: flatbuffers.Builder, pos: Any):
def AddPos(builder, pos):
MonsterAddPos(builder, pos)
def MonsterAddMana(builder, mana):
builder.PrependInt16Slot(1, mana, 150)
def AddMana(builder: flatbuffers.Builder, mana: int):
def AddMana(builder, mana):
MonsterAddMana(builder, mana)
def MonsterAddHp(builder, hp):
builder.PrependInt16Slot(2, hp, 100)
def AddHp(builder: flatbuffers.Builder, hp: int):
def AddHp(builder, hp):
MonsterAddHp(builder, hp)
def MonsterAddName(builder, name):
builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def AddName(builder: flatbuffers.Builder, name: int):
def AddName(builder, name):
MonsterAddName(builder, name)
def MonsterAddInventory(builder, inventory):
builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
def AddInventory(builder: flatbuffers.Builder, inventory: int):
def AddInventory(builder, inventory):
MonsterAddInventory(builder, inventory)
def MonsterStartInventoryVector(builder, numElems):
@@ -917,25 +917,25 @@ def StartInventoryVector(builder, numElems: int) -> int:
def MonsterAddColor(builder, color):
builder.PrependUint8Slot(6, color, 8)
def AddColor(builder: flatbuffers.Builder, color: int):
def AddColor(builder, color):
MonsterAddColor(builder, color)
def MonsterAddTestType(builder, testType):
builder.PrependUint8Slot(7, testType, 0)
def AddTestType(builder: flatbuffers.Builder, testType: int):
def AddTestType(builder, testType):
MonsterAddTestType(builder, testType)
def MonsterAddTest(builder, test):
builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
def AddTest(builder: flatbuffers.Builder, test: int):
def AddTest(builder, test):
MonsterAddTest(builder, test)
def MonsterAddTest4(builder, test4):
builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
def AddTest4(builder: flatbuffers.Builder, test4: int):
def AddTest4(builder, test4):
MonsterAddTest4(builder, test4)
def MonsterStartTest4Vector(builder, numElems):
@@ -947,7 +947,7 @@ def StartTest4Vector(builder, numElems: int) -> int:
def MonsterAddTestarrayofstring(builder, testarrayofstring):
builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
def AddTestarrayofstring(builder: flatbuffers.Builder, testarrayofstring: int):
def AddTestarrayofstring(builder, testarrayofstring):
MonsterAddTestarrayofstring(builder, testarrayofstring)
def MonsterStartTestarrayofstringVector(builder, numElems):
@@ -959,7 +959,7 @@ def StartTestarrayofstringVector(builder, numElems: int) -> int:
def MonsterAddTestarrayoftables(builder, testarrayoftables):
builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
def AddTestarrayoftables(builder: flatbuffers.Builder, testarrayoftables: int):
def AddTestarrayoftables(builder, testarrayoftables):
MonsterAddTestarrayoftables(builder, testarrayoftables)
def MonsterStartTestarrayoftablesVector(builder, numElems):
@@ -971,13 +971,13 @@ def StartTestarrayoftablesVector(builder, numElems: int) -> int:
def MonsterAddEnemy(builder, enemy):
builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
def AddEnemy(builder: flatbuffers.Builder, enemy: int):
def AddEnemy(builder, enemy):
MonsterAddEnemy(builder, enemy)
def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
def AddTestnestedflatbuffer(builder: flatbuffers.Builder, testnestedflatbuffer: int):
def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
def MonsterStartTestnestedflatbufferVector(builder, numElems):
@@ -996,67 +996,67 @@ def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
def MonsterAddTestempty(builder, testempty):
builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
def AddTestempty(builder: flatbuffers.Builder, testempty: int):
def AddTestempty(builder, testempty):
MonsterAddTestempty(builder, testempty)
def MonsterAddTestbool(builder, testbool):
builder.PrependBoolSlot(15, testbool, 0)
def AddTestbool(builder: flatbuffers.Builder, testbool: bool):
def AddTestbool(builder, testbool):
MonsterAddTestbool(builder, testbool)
def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
def AddTesthashs32Fnv1(builder: flatbuffers.Builder, testhashs32Fnv1: int):
def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
def AddTesthashu32Fnv1(builder: flatbuffers.Builder, testhashu32Fnv1: int):
def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
def AddTesthashs64Fnv1(builder: flatbuffers.Builder, testhashs64Fnv1: int):
def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
def AddTesthashu64Fnv1(builder: flatbuffers.Builder, testhashu64Fnv1: int):
def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
def AddTesthashs32Fnv1a(builder: flatbuffers.Builder, testhashs32Fnv1a: int):
def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
def AddTesthashu32Fnv1a(builder: flatbuffers.Builder, testhashu32Fnv1a: int):
def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
def AddTesthashs64Fnv1a(builder: flatbuffers.Builder, testhashs64Fnv1a: int):
def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
def AddTesthashu64Fnv1a(builder: flatbuffers.Builder, testhashu64Fnv1a: int):
def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
def MonsterAddTestarrayofbools(builder, testarrayofbools):
builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
def AddTestarrayofbools(builder: flatbuffers.Builder, testarrayofbools: int):
def AddTestarrayofbools(builder, testarrayofbools):
MonsterAddTestarrayofbools(builder, testarrayofbools)
def MonsterStartTestarrayofboolsVector(builder, numElems):
@@ -1068,25 +1068,25 @@ def StartTestarrayofboolsVector(builder, numElems: int) -> int:
def MonsterAddTestf(builder, testf):
builder.PrependFloat32Slot(25, testf, 3.14159)
def AddTestf(builder: flatbuffers.Builder, testf: float):
def AddTestf(builder, testf):
MonsterAddTestf(builder, testf)
def MonsterAddTestf2(builder, testf2):
builder.PrependFloat32Slot(26, testf2, 3.0)
def AddTestf2(builder: flatbuffers.Builder, testf2: float):
def AddTestf2(builder, testf2):
MonsterAddTestf2(builder, testf2)
def MonsterAddTestf3(builder, testf3):
builder.PrependFloat32Slot(27, testf3, 0.0)
def AddTestf3(builder: flatbuffers.Builder, testf3: float):
def AddTestf3(builder, testf3):
MonsterAddTestf3(builder, testf3)
def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
def AddTestarrayofstring2(builder: flatbuffers.Builder, testarrayofstring2: int):
def AddTestarrayofstring2(builder, testarrayofstring2):
MonsterAddTestarrayofstring2(builder, testarrayofstring2)
def MonsterStartTestarrayofstring2Vector(builder, numElems):
@@ -1098,7 +1098,7 @@ def StartTestarrayofstring2Vector(builder, numElems: int) -> int:
def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
def AddTestarrayofsortedstruct(builder: flatbuffers.Builder, testarrayofsortedstruct: int):
def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
def MonsterStartTestarrayofsortedstructVector(builder, numElems):
@@ -1110,7 +1110,7 @@ def StartTestarrayofsortedstructVector(builder, numElems: int) -> int:
def MonsterAddFlex(builder, flex):
builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
def AddFlex(builder: flatbuffers.Builder, flex: int):
def AddFlex(builder, flex):
MonsterAddFlex(builder, flex)
def MonsterStartFlexVector(builder, numElems):
@@ -1122,7 +1122,7 @@ def StartFlexVector(builder, numElems: int) -> int:
def MonsterAddTest5(builder, test5):
builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
def AddTest5(builder: flatbuffers.Builder, test5: int):
def AddTest5(builder, test5):
MonsterAddTest5(builder, test5)
def MonsterStartTest5Vector(builder, numElems):
@@ -1134,7 +1134,7 @@ def StartTest5Vector(builder, numElems: int) -> int:
def MonsterAddVectorOfLongs(builder, vectorOfLongs):
builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
def AddVectorOfLongs(builder: flatbuffers.Builder, vectorOfLongs: int):
def AddVectorOfLongs(builder, vectorOfLongs):
MonsterAddVectorOfLongs(builder, vectorOfLongs)
def MonsterStartVectorOfLongsVector(builder, numElems):
@@ -1146,7 +1146,7 @@ def StartVectorOfLongsVector(builder, numElems: int) -> int:
def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
def AddVectorOfDoubles(builder: flatbuffers.Builder, vectorOfDoubles: int):
def AddVectorOfDoubles(builder, vectorOfDoubles):
MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
def MonsterStartVectorOfDoublesVector(builder, numElems):
@@ -1158,13 +1158,13 @@ def StartVectorOfDoublesVector(builder, numElems: int) -> int:
def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
def AddParentNamespaceTest(builder: flatbuffers.Builder, parentNamespaceTest: int):
def AddParentNamespaceTest(builder, parentNamespaceTest):
MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
def AddVectorOfReferrables(builder: flatbuffers.Builder, vectorOfReferrables: int):
def AddVectorOfReferrables(builder, vectorOfReferrables):
MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
def MonsterStartVectorOfReferrablesVector(builder, numElems):
@@ -1176,13 +1176,13 @@ def StartVectorOfReferrablesVector(builder, numElems: int) -> int:
def MonsterAddSingleWeakReference(builder, singleWeakReference):
builder.PrependUint64Slot(36, singleWeakReference, 0)
def AddSingleWeakReference(builder: flatbuffers.Builder, singleWeakReference: int):
def AddSingleWeakReference(builder, singleWeakReference):
MonsterAddSingleWeakReference(builder, singleWeakReference)
def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
def AddVectorOfWeakReferences(builder: flatbuffers.Builder, vectorOfWeakReferences: int):
def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
@@ -1194,7 +1194,7 @@ def StartVectorOfWeakReferencesVector(builder, numElems: int) -> int:
def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
def AddVectorOfStrongReferrables(builder: flatbuffers.Builder, vectorOfStrongReferrables: int):
def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
@@ -1206,13 +1206,13 @@ def StartVectorOfStrongReferrablesVector(builder, numElems: int) -> int:
def MonsterAddCoOwningReference(builder, coOwningReference):
builder.PrependUint64Slot(39, coOwningReference, 0)
def AddCoOwningReference(builder: flatbuffers.Builder, coOwningReference: int):
def AddCoOwningReference(builder, coOwningReference):
MonsterAddCoOwningReference(builder, coOwningReference)
def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
def AddVectorOfCoOwningReferences(builder: flatbuffers.Builder, vectorOfCoOwningReferences: int):
def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
@@ -1224,13 +1224,13 @@ def StartVectorOfCoOwningReferencesVector(builder, numElems: int) -> int:
def MonsterAddNonOwningReference(builder, nonOwningReference):
builder.PrependUint64Slot(41, nonOwningReference, 0)
def AddNonOwningReference(builder: flatbuffers.Builder, nonOwningReference: int):
def AddNonOwningReference(builder, nonOwningReference):
MonsterAddNonOwningReference(builder, nonOwningReference)
def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
def AddVectorOfNonOwningReferences(builder: flatbuffers.Builder, vectorOfNonOwningReferences: int):
def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
@@ -1242,31 +1242,31 @@ def StartVectorOfNonOwningReferencesVector(builder, numElems: int) -> int:
def MonsterAddAnyUniqueType(builder, anyUniqueType):
builder.PrependUint8Slot(43, anyUniqueType, 0)
def AddAnyUniqueType(builder: flatbuffers.Builder, anyUniqueType: int):
def AddAnyUniqueType(builder, anyUniqueType):
MonsterAddAnyUniqueType(builder, anyUniqueType)
def MonsterAddAnyUnique(builder, anyUnique):
builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
def AddAnyUnique(builder: flatbuffers.Builder, anyUnique: int):
def AddAnyUnique(builder, anyUnique):
MonsterAddAnyUnique(builder, anyUnique)
def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
builder.PrependUint8Slot(45, anyAmbiguousType, 0)
def AddAnyAmbiguousType(builder: flatbuffers.Builder, anyAmbiguousType: int):
def AddAnyAmbiguousType(builder, anyAmbiguousType):
MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
def AddAnyAmbiguous(builder: flatbuffers.Builder, anyAmbiguous: int):
def AddAnyAmbiguous(builder, anyAmbiguous):
MonsterAddAnyAmbiguous(builder, anyAmbiguous)
def MonsterAddVectorOfEnums(builder, vectorOfEnums):
builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
def AddVectorOfEnums(builder: flatbuffers.Builder, vectorOfEnums: int):
def AddVectorOfEnums(builder, vectorOfEnums):
MonsterAddVectorOfEnums(builder, vectorOfEnums)
def MonsterStartVectorOfEnumsVector(builder, numElems):
@@ -1278,13 +1278,13 @@ def StartVectorOfEnumsVector(builder, numElems: int) -> int:
def MonsterAddSignedEnum(builder, signedEnum):
builder.PrependInt8Slot(48, signedEnum, -1)
def AddSignedEnum(builder: flatbuffers.Builder, signedEnum: int):
def AddSignedEnum(builder, signedEnum):
MonsterAddSignedEnum(builder, signedEnum)
def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
def AddTestrequirednestedflatbuffer(builder: flatbuffers.Builder, testrequirednestedflatbuffer: int):
def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
@@ -1303,7 +1303,7 @@ def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
def AddScalarKeySortedTables(builder: flatbuffers.Builder, scalarKeySortedTables: int):
def AddScalarKeySortedTables(builder, scalarKeySortedTables):
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
def MonsterStartScalarKeySortedTablesVector(builder, numElems):
@@ -1315,67 +1315,67 @@ def StartScalarKeySortedTablesVector(builder, numElems: int) -> int:
def MonsterAddNativeInline(builder, nativeInline):
builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
def AddNativeInline(builder: flatbuffers.Builder, nativeInline: Any):
def AddNativeInline(builder, nativeInline):
MonsterAddNativeInline(builder, nativeInline)
def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
def AddLongEnumNonEnumDefault(builder: flatbuffers.Builder, longEnumNonEnumDefault: int):
def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault):
builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
def AddLongEnumNormalDefault(builder: flatbuffers.Builder, longEnumNormalDefault: int):
def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
def MonsterAddNanDefault(builder, nanDefault):
builder.PrependFloat32Slot(54, nanDefault, float('nan'))
def AddNanDefault(builder: flatbuffers.Builder, nanDefault: float):
def AddNanDefault(builder, nanDefault):
MonsterAddNanDefault(builder, nanDefault)
def MonsterAddInfDefault(builder, infDefault):
builder.PrependFloat32Slot(55, infDefault, float('inf'))
def AddInfDefault(builder: flatbuffers.Builder, infDefault: float):
def AddInfDefault(builder, infDefault):
MonsterAddInfDefault(builder, infDefault)
def MonsterAddPositiveInfDefault(builder, positiveInfDefault):
builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
def AddPositiveInfDefault(builder: flatbuffers.Builder, positiveInfDefault: float):
def AddPositiveInfDefault(builder, positiveInfDefault):
MonsterAddPositiveInfDefault(builder, positiveInfDefault)
def MonsterAddInfinityDefault(builder, infinityDefault):
builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
def AddInfinityDefault(builder: flatbuffers.Builder, infinityDefault: float):
def AddInfinityDefault(builder, infinityDefault):
MonsterAddInfinityDefault(builder, infinityDefault)
def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault):
builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
def AddPositiveInfinityDefault(builder: flatbuffers.Builder, positiveInfinityDefault: float):
def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
def MonsterAddNegativeInfDefault(builder, negativeInfDefault):
builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
def AddNegativeInfDefault(builder: flatbuffers.Builder, negativeInfDefault: float):
def AddNegativeInfDefault(builder, negativeInfDefault):
MonsterAddNegativeInfDefault(builder, negativeInfDefault)
def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault):
builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
def AddNegativeInfinityDefault(builder: flatbuffers.Builder, negativeInfinityDefault: float):
def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
def MonsterAddDoubleInfDefault(builder, doubleInfDefault):
builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
def AddDoubleInfDefault(builder: flatbuffers.Builder, doubleInfDefault: float):
def AddDoubleInfDefault(builder, doubleInfDefault):
MonsterAddDoubleInfDefault(builder, doubleInfDefault)
def MonsterEnd(builder):

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

@@ -5,7 +5,7 @@
import flatbuffers
from flatbuffers.compat import import_numpy
from typing import Any
from .MyGame.Example.NestedUnion.Test import Test
from MyGame.Example.NestedUnion.Test import Test
from typing import Optional
np = import_numpy()

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

@@ -44,7 +44,7 @@ def Start(builder):
def ReferrableAddId(builder, id):
builder.PrependUint64Slot(0, id, 0)
def AddId(builder: flatbuffers.Builder, id: int):
def AddId(builder, id):
ReferrableAddId(builder, id)
def ReferrableEnd(builder):

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

@@ -58,19 +58,19 @@ def Start(builder):
def StatAddId(builder, id):
builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
def AddId(builder: flatbuffers.Builder, id: int):
def AddId(builder, id):
StatAddId(builder, id)
def StatAddVal(builder, val):
builder.PrependInt64Slot(1, val, 0)
def AddVal(builder: flatbuffers.Builder, val: int):
def AddVal(builder, val):
StatAddVal(builder, val)
def StatAddCount(builder, count):
builder.PrependUint16Slot(2, count, 0)
def AddCount(builder: flatbuffers.Builder, count: int):
def AddCount(builder, count):
StatAddCount(builder, count)
def StatEnd(builder):

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

@@ -44,7 +44,7 @@ def Start(builder):
def TestSimpleTableWithEnumAddColor(builder, color):
builder.PrependUint8Slot(0, color, 2)
def AddColor(builder: flatbuffers.Builder, color: int):
def AddColor(builder, color):
TestSimpleTableWithEnumAddColor(builder, color)
def TestSimpleTableWithEnumEnd(builder):

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

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