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.

4 files changed, 105 insertions, 42 deletions

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