From 13d9e35858fe8c96f7244bf0e4b66af2b24b59f3 Mon Sep 17 00:00:00 2001 From: Richard A Hofer Date: Thu, 28 Jan 2021 15:35:37 -0500 Subject: Better python generated code naming (#6336) * Remove a lot of redundancy from the Python generated code. Update tutorial to reflect new Python generated code. * Add aliases for newly deprecated Python generated methods. This should help with backwards compatibility. * Fix incorrect names in deprecated comments. --- .../NamespaceA/NamespaceB/TableInNestedNS.py | 28 +++++++---- tests/namespace_test/NamespaceA/SecondTableInA.py | 28 +++++++---- tests/namespace_test/NamespaceA/TableInFirstNS.py | 56 +++++++++++++++------- tests/namespace_test/NamespaceC/TableInC.py | 35 ++++++++++---- 4 files changed, 105 insertions(+), 42 deletions(-) (limited to 'tests/namespace_test') diff --git a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py index 19b87e1d..7a4ff9d7 100644 --- a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py +++ b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py @@ -10,12 +10,16 @@ class TableInNestedNS(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTableInNestedNS(cls, buf, offset=0): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TableInNestedNS() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTableInNestedNS(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) # TableInNestedNS def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -27,10 +31,18 @@ class TableInNestedNS(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def TableInNestedNSStart(builder): builder.StartObject(1) -def TableInNestedNSAddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0) -def TableInNestedNSEnd(builder): return builder.EndObject() - +def Start(builder): builder.StartObject(1) +def TableInNestedNSStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0) +def TableInNestedNSAddFoo(builder, foo): + """This method is deprecated. Please switch to AddFoo.""" + return AddFoo(builder, foo) +def End(builder): return builder.EndObject() +def TableInNestedNSEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) class TableInNestedNST(object): @@ -58,7 +70,7 @@ class TableInNestedNST(object): # TableInNestedNST def Pack(self, builder): - TableInNestedNSStart(builder) - TableInNestedNSAddFoo(builder, self.foo) - tableInNestedNS = TableInNestedNSEnd(builder) + Start(builder) + AddFoo(builder, self.foo) + tableInNestedNS = End(builder) return tableInNestedNS diff --git a/tests/namespace_test/NamespaceA/SecondTableInA.py b/tests/namespace_test/NamespaceA/SecondTableInA.py index ade8fdbe..f97cf062 100644 --- a/tests/namespace_test/NamespaceA/SecondTableInA.py +++ b/tests/namespace_test/NamespaceA/SecondTableInA.py @@ -10,12 +10,16 @@ class SecondTableInA(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSecondTableInA(cls, buf, offset=0): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SecondTableInA() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsSecondTableInA(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) # SecondTableInA def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -30,10 +34,18 @@ class SecondTableInA(object): return obj return None -def SecondTableInAStart(builder): builder.StartObject(1) -def SecondTableInAAddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0) -def SecondTableInAEnd(builder): return builder.EndObject() - +def Start(builder): builder.StartObject(1) +def SecondTableInAStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0) +def SecondTableInAAddReferToC(builder, referToC): + """This method is deprecated. Please switch to AddReferToC.""" + return AddReferToC(builder, referToC) +def End(builder): return builder.EndObject() +def SecondTableInAEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) try: from typing import Optional except: @@ -68,8 +80,8 @@ class SecondTableInAT(object): def Pack(self, builder): if self.referToC is not None: referToC = self.referToC.Pack(builder) - SecondTableInAStart(builder) + Start(builder) if self.referToC is not None: - SecondTableInAAddReferToC(builder, referToC) - secondTableInA = SecondTableInAEnd(builder) + AddReferToC(builder, referToC) + secondTableInA = End(builder) return secondTableInA diff --git a/tests/namespace_test/NamespaceA/TableInFirstNS.py b/tests/namespace_test/NamespaceA/TableInFirstNS.py index abaac47c..d2c7e4aa 100644 --- a/tests/namespace_test/NamespaceA/TableInFirstNS.py +++ b/tests/namespace_test/NamespaceA/TableInFirstNS.py @@ -10,12 +10,16 @@ class TableInFirstNS(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTableInFirstNS(cls, buf, offset=0): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TableInFirstNS() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTableInFirstNS(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) # TableInFirstNS def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -64,14 +68,34 @@ class TableInFirstNS(object): return obj return None -def TableInFirstNSStart(builder): builder.StartObject(5) -def TableInFirstNSAddFooTable(builder, fooTable): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fooTable), 0) -def TableInFirstNSAddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0) -def TableInFirstNSAddFooUnionType(builder, fooUnionType): builder.PrependUint8Slot(2, fooUnionType, 0) -def TableInFirstNSAddFooUnion(builder, fooUnion): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fooUnion), 0) -def TableInFirstNSAddFooStruct(builder, fooStruct): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0) -def TableInFirstNSEnd(builder): return builder.EndObject() - +def Start(builder): builder.StartObject(5) +def TableInFirstNSStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddFooTable(builder, fooTable): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fooTable), 0) +def TableInFirstNSAddFooTable(builder, fooTable): + """This method is deprecated. Please switch to AddFooTable.""" + return AddFooTable(builder, fooTable) +def AddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0) +def TableInFirstNSAddFooEnum(builder, fooEnum): + """This method is deprecated. Please switch to AddFooEnum.""" + return AddFooEnum(builder, fooEnum) +def AddFooUnionType(builder, fooUnionType): builder.PrependUint8Slot(2, fooUnionType, 0) +def TableInFirstNSAddFooUnionType(builder, fooUnionType): + """This method is deprecated. Please switch to AddFooUnionType.""" + return AddFooUnionType(builder, fooUnionType) +def AddFooUnion(builder, fooUnion): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fooUnion), 0) +def TableInFirstNSAddFooUnion(builder, fooUnion): + """This method is deprecated. Please switch to AddFooUnion.""" + return AddFooUnion(builder, fooUnion) +def AddFooStruct(builder, fooStruct): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0) +def TableInFirstNSAddFooStruct(builder, fooStruct): + """This method is deprecated. Please switch to AddFooStruct.""" + return AddFooStruct(builder, fooStruct) +def End(builder): return builder.EndObject() +def TableInFirstNSEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) try: from typing import Optional, Union except: @@ -117,15 +141,15 @@ class TableInFirstNST(object): fooTable = self.fooTable.Pack(builder) if self.fooUnion is not None: fooUnion = self.fooUnion.Pack(builder) - TableInFirstNSStart(builder) + Start(builder) if self.fooTable is not None: - TableInFirstNSAddFooTable(builder, fooTable) - TableInFirstNSAddFooEnum(builder, self.fooEnum) - TableInFirstNSAddFooUnionType(builder, self.fooUnionType) + AddFooTable(builder, fooTable) + AddFooEnum(builder, self.fooEnum) + AddFooUnionType(builder, self.fooUnionType) if self.fooUnion is not None: - TableInFirstNSAddFooUnion(builder, fooUnion) + AddFooUnion(builder, fooUnion) if self.fooStruct is not None: fooStruct = self.fooStruct.Pack(builder) - TableInFirstNSAddFooStruct(builder, fooStruct) - tableInFirstNS = TableInFirstNSEnd(builder) + AddFooStruct(builder, fooStruct) + tableInFirstNS = End(builder) return tableInFirstNS diff --git a/tests/namespace_test/NamespaceC/TableInC.py b/tests/namespace_test/NamespaceC/TableInC.py index 1abb5e36..b8d3b94f 100644 --- a/tests/namespace_test/NamespaceC/TableInC.py +++ b/tests/namespace_test/NamespaceC/TableInC.py @@ -10,12 +10,16 @@ class TableInC(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTableInC(cls, buf, offset=0): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TableInC() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTableInC(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) # TableInC def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -40,11 +44,22 @@ class TableInC(object): return obj return None -def TableInCStart(builder): builder.StartObject(2) -def TableInCAddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0) -def TableInCAddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0) -def TableInCEnd(builder): return builder.EndObject() - +def Start(builder): builder.StartObject(2) +def TableInCStart(builder): + """This method is deprecated. Please switch to Start.""" + return Start(builder) +def AddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0) +def TableInCAddReferToA1(builder, referToA1): + """This method is deprecated. Please switch to AddReferToA1.""" + return AddReferToA1(builder, referToA1) +def AddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0) +def TableInCAddReferToA2(builder, referToA2): + """This method is deprecated. Please switch to AddReferToA2.""" + return AddReferToA2(builder, referToA2) +def End(builder): return builder.EndObject() +def TableInCEnd(builder): + """This method is deprecated. Please switch to End.""" + return End(builder) try: from typing import Optional except: @@ -84,10 +99,10 @@ class TableInCT(object): referToA1 = self.referToA1.Pack(builder) if self.referToA2 is not None: referToA2 = self.referToA2.Pack(builder) - TableInCStart(builder) + Start(builder) if self.referToA1 is not None: - TableInCAddReferToA1(builder, referToA1) + AddReferToA1(builder, referToA1) if self.referToA2 is not None: - TableInCAddReferToA2(builder, referToA2) - tableInC = TableInCEnd(builder) + AddReferToA2(builder, referToA2) + tableInC = End(builder) return tableInC -- cgit v1.2.3