From 9d8ca2746b2d71970819ddc9261e0a8a92532920 Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Thu, 8 Sep 2022 13:45:13 +0100
Subject: [PATCH 01/10] feat: Added support for fixed sized arrays to python

Problem:
We encountered that using fixed arrays from C++ to python that python would
not read those arrays correctly due to no size information being encoded in the byte
array itself.

Fix:
Encode the sizes within the generated python file during code generation.
Specfically we add GetArrayAsNumpy to the python version of table, which takes as input
the length of the vector. When generating the python message files we include this length
from the VectorType().fixed_length.
---
 python/flatbuffers/table.py | 11 ++++++-
 src/idl_gen_python.cpp      | 60 ++++++++++++++++++++++++-------------
 2 files changed, 50 insertions(+), 21 deletions(-)

diff --git a/python/flatbuffers/table.py b/python/flatbuffers/table.py
index adc76ca8d77..d5336ca6b04 100644
--- a/python/flatbuffers/table.py
+++ b/python/flatbuffers/table.py
@@ -113,6 +113,15 @@ def GetVectorAsNumpy(self, flags, off):
         numpy_dtype = N.to_numpy_type(flags)
         return encode.GetVectorAsNumpy(numpy_dtype, self.Bytes, length, offset)
 
+    def GetArrayAsNumpy(self, flags, off, length):
+        """
+        GetArrayAsNumpy returns the array with fixed width that starts at `Vector(offset)`
+        with length `length` as a numpy array with the type specified by `flags`. The
+        array is a `view` into Bytes so modifying the returned will modify Bytes in place.
+        """
+        numpy_dtype = N.to_numpy_type(flags)
+        return encode.GetVectorAsNumpy(numpy_dtype, self.Bytes, length, off)
+
     def GetVOffsetTSlot(self, slot, d):
         """
         GetVOffsetTSlot retrieves the VOffsetT that the given vtable location
@@ -125,5 +134,5 @@ def GetVOffsetTSlot(self, slot, d):
 
         off = self.Offset(slot)
         if off == 0:
-                return d
+            return d
         return off
diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 0b8ffa821e8..81c9d2ee642 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -164,9 +164,14 @@ class PythonGenerator : public BaseGenerator {
 
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field) + "Length(self";
-    code += "):" + OffsetPrefix(field);
-    code += Indent + Indent + Indent + "return self._tab.VectorLen(o)\n";
-    code += Indent + Indent + "return 0\n\n";
+    code += "):";
+    if(!IsArray(field.value.type)){
+      code += OffsetPrefix(field);
+      code += GenIndents(3) + "return self._tab.VectorLen(o)\n";
+      code += GenIndents(2) + "return 0\n\n";
+    }else{
+      code += GenIndents(2) + "return "+NumToString(field.value.type.fixed_length)+"\n\n";
+    }
   }
 
   // Determines whether a vector is none or not.
@@ -177,10 +182,15 @@ class PythonGenerator : public BaseGenerator {
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field) + "IsNone(self";
     code += "):";
-    code += GenIndents(2) +
-            "o = flatbuffers.number_types.UOffsetTFlags.py_type" +
-            "(self._tab.Offset(" + NumToString(field.value.offset) + "))";
-    code += GenIndents(2) + "return o == 0";
+    if(!IsArray(field.value.type)){
+      code += GenIndents(2) +
+              "o = flatbuffers.number_types.UOffsetTFlags.py_type" +
+              "(self._tab.Offset(" + NumToString(field.value.offset) + "))";
+      code += GenIndents(2) + "return o == 0";
+    } else {
+      //assume that we always have an array as memory is preassigned
+      code += GenIndents(2) + "return False";
+    }
     code += "\n\n";
   }
 
@@ -252,12 +262,13 @@ class PythonGenerator : public BaseGenerator {
       code += ")\n" + Indent + Indent + "return obj\n\n";
     } else {
       auto getter = GenGetter(vec_type);
-      code += "(self): return [" + getter;
+      code += "(self):";
+      code += GenIndents(2) + "return [" + getter;
       code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
       code += NumToString(field.value.offset) + " + i * ";
       code += NumToString(InlineSize(vec_type));
       code += ")) for i in range(";
-      code += NumToString(field.value.type.fixed_length) + ")]\n";
+      code += NumToString(field.value.type.fixed_length) + ")]\n\n";
     }
   }
 
@@ -403,18 +414,25 @@ class PythonGenerator : public BaseGenerator {
 
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field) + "AsNumpy(self):";
-    code += OffsetPrefix(field);
+    if(!IsArray(field.value.type)){
+      code += OffsetPrefix(field);
 
-    code += Indent + Indent + Indent;
-    code += "return ";
-    code += "self._tab.GetVectorAsNumpy(flatbuffers.number_types.";
-    code += namer_.Method(GenTypeGet(field.value.type));
-    code += "Flags, o)\n";
+      code += GenIndents(3);
+      code += "return ";
+      code += "self._tab.GetVectorAsNumpy(flatbuffers.number_types.";
+      code += namer_.Method(GenTypeGet(field.value.type));
+      code += "Flags, o)\n";
 
-    if (IsString(vectortype)) {
-      code += Indent + Indent + "return \"\"\n";
-    } else {
-      code += Indent + Indent + "return 0\n";
+      if (IsString(vectortype)) {
+        code += GenIndents(2) + "return \"\"\n";
+      } else {
+        code += GenIndents(2) + "return 0\n";
+      }
+    }else{
+      code += GenIndents(2) + "return ";
+      code += "self._tab.GetArrayAsNumpy(flatbuffers.number_types.";
+      code += namer_.Method(GenTypeGet(field.value.type.VectorType()));
+      code += "Flags, self._tab.Pos + "+NumToString(field.value.offset)+", "+NumToString(field.value.type.VectorType().fixed_length)+")\n";
     }
     code += "\n";
   }
@@ -716,6 +734,7 @@ class PythonGenerator : public BaseGenerator {
       }
     } else if (IsArray(field.value.type)) {
       GetArrayOfStruct(struct_def, field, code_ptr);
+      GetVectorOfNonStructAsNumpy(struct_def, field, code_ptr);
     } else {
       switch (field.value.type.base_type) {
         case BASE_TYPE_STRUCT:
@@ -1061,8 +1080,9 @@ class PythonGenerator : public BaseGenerator {
 
     code += GenIndents(1) + "@classmethod";
     code += GenIndents(1) + "def InitFromBuf(cls, buf, pos):";
+    code += GenIndents(2) + "n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)";
     code += GenIndents(2) + struct_var + " = " + struct_type + "()";
-    code += GenIndents(2) + struct_var + ".Init(buf, pos)";
+    code += GenIndents(2) + struct_var + ".Init(buf, pos+n)";
     code += GenIndents(2) + "return cls.InitFromObj(" + struct_var + ")";
     code += "\n";
   }

From 5fd40f6e4e3cbe737ce87d6e7edc180ed0442390 Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Thu, 8 Sep 2022 13:58:21 +0100
Subject: [PATCH 02/10] fix: added digit support for camel case to snake case
 conversion

Problem:
When including a number in the message name we would encounter cases where SnakeCase would
not add the appropirate breaks. e.g. Int32Stamped -> int_32stamped rather than int_32_stamped.

Fix:
To fix this we can add the condition that we check if the current character is not lower and
not a digit, that we check if the previous character was a lower or digit. If it was a lower
or digit then we add the break.
---
 src/util.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/util.cpp b/src/util.cpp
index 341b8aa6ed0..2b18fd6ba76 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -109,7 +109,7 @@ static std::string ToSnakeCase(const std::string &input, bool screaming) {
     } else if (!islower(input[i])) {
       // Prevent duplicate underscores for Upper_Snake_Case strings
       // and UPPERCASE strings.
-      if (islower(input[i - 1])) { s += '_'; }
+      if (islower(input[i - 1]) || (isdigit(input[i-1]) && !isdigit(input[i]))) { s += '_'; }
       s += screaming ? CharToUpper(input[i]) : CharToLower(input[i]);
     } else {
       s += screaming ? CharToUpper(input[i]) : input[i];

From 46299ddec1b3cf0bcfb83261d1e48f4b639d6d61 Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Tue, 13 Sep 2022 09:58:02 +0100
Subject: [PATCH 03/10] fix: Array support for structures

Problem:
The python generated code for handling non-struct and struct vectors
and arrays was inconsistent. The calls to populate the obj api was
creating incorrect code.

Solution:
To fix this the VectorOfStruct and VectorOfNonStruct was rewritten
to handle array cases and bring the two methods in line which each
other.

Testing:
PythonTesting.sh now correctly runs and generates the code for
array_test.fbs.
Minor modifications were done on the test to use the new index
accessor for struct arrays and the script correctly sources the
location of the python code.
---
 src/idl_gen_python.cpp | 108 ++++++++++++++++++++++++++++++-----------
 tests/PythonTest.sh    |   5 +-
 tests/py_test.py       |  17 +++----
 3 files changed, 92 insertions(+), 38 deletions(-)

diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 81c9d2ee642..2be5b6be3ed 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -21,6 +21,7 @@
 #include <string>
 #include <unordered_set>
 #include <vector>
+#include <iostream>
 
 #include "flatbuffers/code_generators.h"
 #include "flatbuffers/flatbuffers.h"
@@ -254,22 +255,43 @@ class PythonGenerator : public BaseGenerator {
     const auto vec_type = field.value.type.VectorType();
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
-    if (IsStruct(vec_type)) {
-      code += "(self, obj, i):\n";
-      code += Indent + Indent + "obj.Init(self._tab.Bytes, self._tab.Pos + ";
-      code += NumToString(field.value.offset) + " + i * ";
-      code += NumToString(InlineSize(vec_type));
-      code += ")\n" + Indent + Indent + "return obj\n\n";
-    } else {
-      auto getter = GenGetter(vec_type);
-      code += "(self):";
-      code += GenIndents(2) + "return [" + getter;
-      code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
-      code += NumToString(field.value.offset) + " + i * ";
-      code += NumToString(InlineSize(vec_type));
-      code += ")) for i in range(";
-      code += NumToString(field.value.type.fixed_length) + ")]\n\n";
+    code += "(self, i: int):";
+    if (parser_.opts.include_dependence_headers) {
+      code += GenIndents(2);
+      code += "from " + GenPackageReference(field.value.type) + " import " +
+              TypeName(field);
     }
+    code += GenIndents(2) + "obj = "+ TypeName(field)+"()";
+    code += GenIndents(2) + "obj.Init(self._tab.Bytes, self._tab.Pos + ";
+    code += NumToString(field.value.offset) + " + i * ";
+    code += NumToString(InlineSize(vec_type));
+    code += ")" + GenIndents(2) + "return obj\n\n";
+  }
+
+   // Get the value of a vector's non-struct member. Uses a named return
+  // argument to conveniently set the zero value for the result.
+  void GetArrayOfNonStruct(const StructDef &struct_def,
+                                    const FieldDef &field,
+                                    std::string *code_ptr) const {
+    auto &code = *code_ptr;
+    GenReceiver(struct_def, code_ptr);
+    code += namer_.Method(field);
+    code += "(self, j):";
+    code += GenIndents(2)+"return " + GenGetter(field.value.type);
+    code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
+    code += NumToString(field.value.offset) + " + j * ";
+    code += NumToString(InlineSize(field.value.type.VectorType()));
+    code += "))\n";
+
+    GenReceiver(struct_def, code_ptr);
+    code += namer_.Method(field);
+    code += "(self):";
+    code += GenIndents(2)+"return [" + GenGetter(field.value.type);
+    code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
+    code += NumToString(field.value.offset) + " + j * ";
+    code += NumToString(InlineSize(field.value.type.VectorType()));
+    code += ")) for j in range(";
+    code += NumToString(field.value.type.fixed_length) + ")]\n\n";
   }
 
   // Get a struct by initializing an existing struct.
@@ -732,9 +754,6 @@ class PythonGenerator : public BaseGenerator {
       } else {
         GetScalarFieldOfTable(struct_def, field, code_ptr);
       }
-    } else if (IsArray(field.value.type)) {
-      GetArrayOfStruct(struct_def, field, code_ptr);
-      GetVectorOfNonStructAsNumpy(struct_def, field, code_ptr);
     } else {
       switch (field.value.type.base_type) {
         case BASE_TYPE_STRUCT:
@@ -758,6 +777,17 @@ class PythonGenerator : public BaseGenerator {
           }
           break;
         }
+        case BASE_TYPE_ARRAY: {
+          auto vectortype = field.value.type.VectorType();
+          if (vectortype.base_type == BASE_TYPE_STRUCT) {
+            GetArrayOfStruct(struct_def, field, code_ptr);
+          } else {
+            GetArrayOfNonStruct(struct_def, field, code_ptr);
+            GetVectorOfNonStructAsNumpy(struct_def, field, code_ptr);
+            GetVectorAsNestedFlatbuffer(struct_def, field, code_ptr);
+          }
+          break;
+        }
         case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break;
         default: FLATBUFFERS_ASSERT(0);
       }
@@ -1163,12 +1193,41 @@ class PythonGenerator : public BaseGenerator {
     auto field_type = TypeName(field);
     auto one_instance = field_type + "_";
     one_instance[0] = CharToLower(one_instance[0]);
-
     if (parser_.opts.include_dependence_headers) {
       auto package_reference = GenPackageReference(field.value.type);
       field_type = package_reference + "." + TypeName(field);
     }
+    code += GenIndents(4) + "if " + struct_var + "." + field_method +
+            "(i) is None:";
+    code += GenIndents(5) + "self." + field_field + ".append(None)";
+    code += GenIndents(4) + "else:";
+    code += GenIndents(5) + one_instance + " = " + field_type +
+            "T.InitFromObj(" + struct_var + "." + field_method + "(i))";
+    code +=
+        GenIndents(5) + "self." + field_field + ".append(" + one_instance + ")";
+  }
+
+  void GenUnpackForTableVector(const StructDef &struct_def,
+                                const FieldDef &field,
+                                std::string *code_ptr) const {
+    auto &code = *code_ptr;
+    const auto field_field = namer_.Field(field);
+    const auto field_method = namer_.Method(field);
+    const auto struct_var = namer_.Variable(struct_def);
 
+    code += GenIndents(2) + "if not " + struct_var + "." + field_method +
+            "IsNone():";
+    code += GenIndents(3) + "self." + field_field + " = []";
+    code += GenIndents(3) + "for i in range(" + struct_var + "." +
+            field_method + "Length()):";
+
+    auto field_type = TypeName(field);
+    auto one_instance = field_type + "_";
+    one_instance[0] = CharToLower(one_instance[0]);
+    if (parser_.opts.include_dependence_headers) {
+      auto package_reference = GenPackageReference(field.value.type);
+      field_type = package_reference + "." + TypeName(field);
+    }
     code += GenIndents(4) + "if " + struct_var + "." + field_method +
             "(i) is None:";
     code += GenIndents(5) + "self." + field_field + ".append(None)";
@@ -1253,6 +1312,7 @@ class PythonGenerator : public BaseGenerator {
           GenUnPackForUnion(struct_def, field, &code);
           break;
         }
+        case BASE_TYPE_ARRAY:
         case BASE_TYPE_VECTOR: {
           auto vectortype = field.value.type.VectorType();
           if (vectortype.base_type == BASE_TYPE_STRUCT) {
@@ -1262,10 +1322,6 @@ class PythonGenerator : public BaseGenerator {
           }
           break;
         }
-        case BASE_TYPE_ARRAY: {
-          GenUnPackForScalarVector(struct_def, field, &code);
-          break;
-        }
         default: GenUnPackForScalar(struct_def, field, &code);
       }
     }
@@ -1502,6 +1558,7 @@ class PythonGenerator : public BaseGenerator {
           GenPackForUnionField(struct_def, field, &code_prefix, &code);
           break;
         }
+        case BASE_TYPE_ARRAY:
         case BASE_TYPE_VECTOR: {
           auto vectortype = field.value.type.VectorType();
           if (vectortype.base_type == BASE_TYPE_STRUCT) {
@@ -1511,10 +1568,6 @@ class PythonGenerator : public BaseGenerator {
           }
           break;
         }
-        case BASE_TYPE_ARRAY: {
-          GenPackForScalarVectorField(struct_def, field, &code_prefix, &code);
-          break;
-        }
         case BASE_TYPE_STRING: {
           code_prefix +=
               GenIndents(2) + "if self." + field_field + " is not None:";
@@ -1687,6 +1740,7 @@ class PythonGenerator : public BaseGenerator {
     switch (type.base_type) {
       case BASE_TYPE_STRING: return "string";
       case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType());
+      case BASE_TYPE_ARRAY: return GenTypeGet(type.VectorType());
       case BASE_TYPE_STRUCT: return type.struct_def->name;
       case BASE_TYPE_UNION:
         // fall through
diff --git a/tests/PythonTest.sh b/tests/PythonTest.sh
index 00772eae39f..0d0ee695b57 100755
--- a/tests/PythonTest.sh
+++ b/tests/PythonTest.sh
@@ -17,12 +17,13 @@
 pushd "$(dirname $0)" >/dev/null
 test_dir="$(pwd)"
 gen_code_path=${test_dir}
-runtime_library_dir=${test_dir}/../python
+runtime_library_dir=${test_dir}/../../python
 
 # Emit Python code for the example schema in the test dir:
 ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_test.fbs --gen-object-api
 ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_test.fbs --gen-object-api --gen-onefile
 ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_extra.fbs --gen-object-api
+${test_dir}/../flatc -p -o ${gen_code_path} -I include_test arrays_test.fbs --gen-object-api
 
 # Syntax: run_tests <interpreter> <benchmark vtable dedupes>
 #                   <benchmark read count> <benchmark build count>
@@ -73,7 +74,7 @@ if $(which coverage >/dev/null); then
 
   PYTHONDONTWRITEBYTECODE=1 \
   PYTHONPATH=${runtime_library_dir}:${gen_code_path} \
-  coverage run --source=flatbuffers,MyGame py_test.py 0 0 0 > /dev/null
+  coverage run --source=flatbuffers,MyGame py_test.py 0 0 0 false > /dev/null
 
   echo
   cov_result=`coverage report --omit="*flatbuffers/vendor*,*py_test*" \
diff --git a/tests/py_test.py b/tests/py_test.py
index 5e3c54735b7..390c93b7914 100644
--- a/tests/py_test.py
+++ b/tests/py_test.py
@@ -2642,24 +2642,23 @@ def test_fixed_length_array(self):
     self.assertEqual(table.A().B(), \
         [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
     self.assertEqual(table.A().C(), 1)
-    self.assertEqual(table.A().D(nested, 0).A(), [1, 2])
-    self.assertEqual(table.A().D(nested, 1).A(), [3, 4])
-    self.assertEqual(table.A().D(nested, 0).B(), \
+    self.assertEqual(table.A().D(0).A(), [1, 2])
+    self.assertEqual(table.A().D(1).A(), [3, 4])
+    self.assertEqual(table.A().D(0).B(), \
         MyGame.Example.TestEnum.TestEnum.B)
-    self.assertEqual(table.A().D(nested, 1).B(), \
+    self.assertEqual(table.A().D(1).B(), \
         MyGame.Example.TestEnum.TestEnum.C)
-    self.assertEqual(table.A().D(nested, 0).C(), \
+    self.assertEqual(table.A().D(0).C(), \
         [MyGame.Example.TestEnum.TestEnum.A, \
          MyGame.Example.TestEnum.TestEnum.B])
-    self.assertEqual(table.A().D(nested, 1).C(), \
+    self.assertEqual(table.A().D(1).C(), \
         [MyGame.Example.TestEnum.TestEnum.C, \
          MyGame.Example.TestEnum.TestEnum.B])
-    self.assertEqual(table.A().D(nested, 0).D(), [-1, 1])
-    self.assertEqual(table.A().D(nested, 1).D(), [-2, 2])
+    self.assertEqual(table.A().D(0).D(), [-1, 1])
+    self.assertEqual(table.A().D(1).D(), [-2, 2])
     self.assertEqual(table.A().E(), 2)
     self.assertEqual(table.A().F(), [-1, 1])
 
-
 def CheckAgainstGoldDataGo():
   try:
     gen_buf, gen_off = make_monster_from_generated_code()

From 146de9c88b99e2fc644940dd348054f80cc9fe8c Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Tue, 13 Sep 2022 10:09:19 +0100
Subject: [PATCH 04/10] chore: clang format changes

---
 src/idl_gen_python.cpp | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 2be5b6be3ed..710f83f775a 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -17,11 +17,11 @@
 // independent from idl_parser, since this code is not needed for most clients
 
 #include <cctype>
+#include <iostream>
 #include <set>
 #include <string>
 #include <unordered_set>
 #include <vector>
-#include <iostream>
 
 #include "flatbuffers/code_generators.h"
 #include "flatbuffers/flatbuffers.h"
@@ -261,23 +261,22 @@ class PythonGenerator : public BaseGenerator {
       code += "from " + GenPackageReference(field.value.type) + " import " +
               TypeName(field);
     }
-    code += GenIndents(2) + "obj = "+ TypeName(field)+"()";
+    code += GenIndents(2) + "obj = " + TypeName(field) + "()";
     code += GenIndents(2) + "obj.Init(self._tab.Bytes, self._tab.Pos + ";
     code += NumToString(field.value.offset) + " + i * ";
     code += NumToString(InlineSize(vec_type));
     code += ")" + GenIndents(2) + "return obj\n\n";
   }
 
-   // Get the value of a vector's non-struct member. Uses a named return
+  // Get the value of a vector's non-struct member. Uses a named return
   // argument to conveniently set the zero value for the result.
-  void GetArrayOfNonStruct(const StructDef &struct_def,
-                                    const FieldDef &field,
-                                    std::string *code_ptr) const {
+  void GetArrayOfNonStruct(const StructDef &struct_def, const FieldDef &field,
+                           std::string *code_ptr) const {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
     code += "(self, j):";
-    code += GenIndents(2)+"return " + GenGetter(field.value.type);
+    code += GenIndents(2) + "return " + GenGetter(field.value.type);
     code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
     code += NumToString(field.value.offset) + " + j * ";
     code += NumToString(InlineSize(field.value.type.VectorType()));
@@ -286,7 +285,7 @@ class PythonGenerator : public BaseGenerator {
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
     code += "(self):";
-    code += GenIndents(2)+"return [" + GenGetter(field.value.type);
+    code += GenIndents(2) + "return [" + GenGetter(field.value.type);
     code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
     code += NumToString(field.value.offset) + " + j * ";
     code += NumToString(InlineSize(field.value.type.VectorType()));
@@ -1208,8 +1207,8 @@ class PythonGenerator : public BaseGenerator {
   }
 
   void GenUnpackForTableVector(const StructDef &struct_def,
-                                const FieldDef &field,
-                                std::string *code_ptr) const {
+                               const FieldDef &field,
+                               std::string *code_ptr) const {
     auto &code = *code_ptr;
     const auto field_field = namer_.Field(field);
     const auto field_method = namer_.Method(field);

From f88247c0918f03bb010a30f181b441d8fa75a5ae Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Thu, 15 Sep 2022 10:38:11 +0100
Subject: [PATCH 05/10] Added code generated by scripts/generate_code. Modified
 GetArrayOfNonStruct slightly to allow for function overloading allowing the
 user to get a single element of an array or the whole array.

---
 python/flatbuffers/reflection/Enum.py         |   6 +
 python/flatbuffers/reflection/EnumVal.py      |   2 +
 python/flatbuffers/reflection/Field.py        |   4 +
 python/flatbuffers/reflection/Object.py       |   6 +
 python/flatbuffers/reflection/RPCCall.py      |   4 +
 python/flatbuffers/reflection/Schema.py       |   8 ++
 python/flatbuffers/reflection/SchemaFile.py   |   2 +
 python/flatbuffers/reflection/Service.py      |   6 +
 src/idl_gen_python.cpp                        |  20 ++--
 tests/MyGame/Example/Ability.py               |   3 +-
 tests/MyGame/Example/ArrayStruct.py           |  57 ++++++----
 tests/MyGame/Example/ArrayTable.py            |   3 +-
 tests/MyGame/Example/Monster.py               |  65 ++++++++++-
 tests/MyGame/Example/NestedStruct.py          |  57 ++++++----
 tests/MyGame/Example/Referrable.py            |   3 +-
 tests/MyGame/Example/Stat.py                  |   3 +-
 tests/MyGame/Example/StructOfStructs.py       |   3 +-
 .../Example/StructOfStructsOfStructs.py       |   3 +-
 tests/MyGame/Example/Test.py                  |   3 +-
 .../MyGame/Example/TestSimpleTableWithEnum.py |   3 +-
 tests/MyGame/Example/TypeAliases.py           |  11 +-
 tests/MyGame/Example/Vec3.py                  |   3 +-
 tests/MyGame/Example2/Monster.py              |   3 +-
 tests/MyGame/InParentNamespace.py             |   3 +-
 tests/MyGame/MonsterExtra.py                  |  11 +-
 tests/monster_test_generated.py               | 106 ++++++++++++++++--
 tests/optional_scalars/ScalarStuff.py         |   3 +-
 tests/py_test.py                              |   4 +
 28 files changed, 322 insertions(+), 83 deletions(-)

diff --git a/python/flatbuffers/reflection/Enum.py b/python/flatbuffers/reflection/Enum.py
index b27e4102c21..fe80f3bdff8 100644
--- a/python/flatbuffers/reflection/Enum.py
+++ b/python/flatbuffers/reflection/Enum.py
@@ -52,7 +52,9 @@ def Values(self, j):
     def ValuesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Enum
@@ -95,7 +97,9 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Enum
@@ -115,7 +119,9 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Enum
diff --git a/python/flatbuffers/reflection/EnumVal.py b/python/flatbuffers/reflection/EnumVal.py
index 62a32dc7f02..67b1b8d967a 100644
--- a/python/flatbuffers/reflection/EnumVal.py
+++ b/python/flatbuffers/reflection/EnumVal.py
@@ -65,7 +65,9 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # EnumVal
diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py
index 01b52808a1f..3a9bce55158 100644
--- a/python/flatbuffers/reflection/Field.py
+++ b/python/flatbuffers/reflection/Field.py
@@ -112,7 +112,9 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Field
@@ -132,7 +134,9 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Field
diff --git a/python/flatbuffers/reflection/Object.py b/python/flatbuffers/reflection/Object.py
index 598927c8af6..53f3597fcd5 100644
--- a/python/flatbuffers/reflection/Object.py
+++ b/python/flatbuffers/reflection/Object.py
@@ -52,7 +52,9 @@ def Fields(self, j):
     def FieldsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Object
@@ -98,7 +100,9 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Object
@@ -118,7 +122,9 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Object
diff --git a/python/flatbuffers/reflection/RPCCall.py b/python/flatbuffers/reflection/RPCCall.py
index 9fdbf468b8f..8c73758ed62 100644
--- a/python/flatbuffers/reflection/RPCCall.py
+++ b/python/flatbuffers/reflection/RPCCall.py
@@ -74,7 +74,9 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # RPCCall
@@ -94,7 +96,9 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # RPCCall
diff --git a/python/flatbuffers/reflection/Schema.py b/python/flatbuffers/reflection/Schema.py
index df2f072f985..6bd4f32af55 100644
--- a/python/flatbuffers/reflection/Schema.py
+++ b/python/flatbuffers/reflection/Schema.py
@@ -45,7 +45,9 @@ def Objects(self, j):
     def ObjectsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Schema
@@ -70,7 +72,9 @@ def Enums(self, j):
     def EnumsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Schema
@@ -120,7 +124,9 @@ def Services(self, j):
     def ServicesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Schema
@@ -154,7 +160,9 @@ def FbsFiles(self, j):
     def FbsFilesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Schema
diff --git a/python/flatbuffers/reflection/SchemaFile.py b/python/flatbuffers/reflection/SchemaFile.py
index 890fd3b5308..003ed24fc85 100644
--- a/python/flatbuffers/reflection/SchemaFile.py
+++ b/python/flatbuffers/reflection/SchemaFile.py
@@ -52,7 +52,9 @@ def IncludedFilenames(self, j):
     def IncludedFilenamesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # SchemaFile
diff --git a/python/flatbuffers/reflection/Service.py b/python/flatbuffers/reflection/Service.py
index d4f1a6a8ea6..3f242aa5390 100644
--- a/python/flatbuffers/reflection/Service.py
+++ b/python/flatbuffers/reflection/Service.py
@@ -52,7 +52,9 @@ def Calls(self, j):
     def CallsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Service
@@ -77,7 +79,9 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Service
@@ -97,7 +101,9 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Service
diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 710f83f775a..100bdeff51a 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -275,22 +275,20 @@ class PythonGenerator : public BaseGenerator {
     auto &code = *code_ptr;
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
-    code += "(self, j):";
-    code += GenIndents(2) + "return " + GenGetter(field.value.type);
+    code += "(self, j = None):";
+    code += GenIndents(2) + "if j==None:";
+    code += GenIndents(3) + "return [" + GenGetter(field.value.type);
     code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
-    code += NumToString(field.value.offset) + " + j * ";
+    code += NumToString(field.value.offset) + " + i * ";
     code += NumToString(InlineSize(field.value.type.VectorType()));
-    code += "))\n";
-
-    GenReceiver(struct_def, code_ptr);
-    code += namer_.Method(field);
-    code += "(self):";
-    code += GenIndents(2) + "return [" + GenGetter(field.value.type);
+    code += ")) for i in range(";
+    code += NumToString(field.value.type.fixed_length) + ")]";
+    code += GenIndents(2) +"else:";
+    code += GenIndents(3) + "return " + GenGetter(field.value.type);
     code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
     code += NumToString(field.value.offset) + " + j * ";
     code += NumToString(InlineSize(field.value.type.VectorType()));
-    code += ")) for j in range(";
-    code += NumToString(field.value.type.fixed_length) + ")]\n\n";
+    code += "))\n";
   }
 
   // Get a struct by initializing an existing struct.
diff --git a/tests/MyGame/Example/Ability.py b/tests/MyGame/Example/Ability.py
index e57dfd74f72..7d3b9552bfd 100644
--- a/tests/MyGame/Example/Ability.py
+++ b/tests/MyGame/Example/Ability.py
@@ -38,8 +38,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         ability = Ability()
-        ability.Init(buf, pos)
+        ability.Init(buf, pos+n)
         return cls.InitFromObj(ability)
 
     @classmethod
diff --git a/tests/MyGame/Example/ArrayStruct.py b/tests/MyGame/Example/ArrayStruct.py
index c80bf6882e1..6be8bac85ea 100644
--- a/tests/MyGame/Example/ArrayStruct.py
+++ b/tests/MyGame/Example/ArrayStruct.py
@@ -20,53 +20,59 @@ def Init(self, buf, pos):
     # ArrayStruct
     def A(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
     # ArrayStruct
-    def B(self): return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + i * 4)) for i in range(15)]
+    def B(self, j = None):
+        if j==None:
+            return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + i * 4)) for i in range(15)]
+        else:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + j * 4))
+    # ArrayStruct
+    def BAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 4, 15)
+
     # ArrayStruct
     def BLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
+        return 15
 
     # ArrayStruct
     def BIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
-        return o == 0
+        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, obj, i):
+    def D(self, i: int):
+        from MyGame.Example.NestedStruct import NestedStruct
+        obj = NestedStruct()
         obj.Init(self._tab.Bytes, self._tab.Pos + 72 + i * 32)
         return obj
 
     # ArrayStruct
     def DLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
+        return 2
 
     # ArrayStruct
     def DIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
-        return o == 0
+        return False
 
     # ArrayStruct
     def E(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(136))
     # ArrayStruct
-    def F(self): return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + i * 8)) for i in range(2)]
+    def F(self, j = None):
+        if j==None:
+            return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + i * 8)) for i in range(2)]
+        else:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + j * 8))
+    # ArrayStruct
+    def FAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 144, 2)
+
     # ArrayStruct
     def FLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(144))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
+        return 2
 
     # ArrayStruct
     def FIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(144))
-        return o == 0
+        return False
 
 
 def CreateArrayStruct(builder, a, b, c, d_a, d_b, d_c, d_d, e, f):
@@ -111,8 +117,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         arrayStruct = ArrayStruct()
-        arrayStruct.Init(buf, pos)
+        arrayStruct.Init(buf, pos+n)
         return cls.InitFromObj(arrayStruct)
 
     @classmethod
@@ -137,7 +144,11 @@ def _UnPack(self, arrayStruct):
         if not arrayStruct.DIsNone():
             self.d = []
             for i in range(arrayStruct.DLength()):
-                self.d.append(arrayStruct.D(i))
+                if arrayStruct.D(i) is None:
+                    self.d.append(None)
+                else:
+                    nestedStruct_ = MyGame.Example.NestedStruct.NestedStructT.InitFromObj(arrayStruct.D(i))
+                    self.d.append(nestedStruct_)
         self.e = arrayStruct.E()
         if not arrayStruct.FIsNone():
             if np is None:
diff --git a/tests/MyGame/Example/ArrayTable.py b/tests/MyGame/Example/ArrayTable.py
index 62d71afa453..0eacdb99d19 100644
--- a/tests/MyGame/Example/ArrayTable.py
+++ b/tests/MyGame/Example/ArrayTable.py
@@ -62,8 +62,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         arrayTable = ArrayTable()
-        arrayTable.Init(buf, pos)
+        arrayTable.Init(buf, pos+n)
         return cls.InitFromObj(arrayTable)
 
     @classmethod
diff --git a/tests/MyGame/Example/Monster.py b/tests/MyGame/Example/Monster.py
index 0044f8d18c4..95b8e2ecddc 100644
--- a/tests/MyGame/Example/Monster.py
+++ b/tests/MyGame/Example/Monster.py
@@ -73,14 +73,18 @@ def Inventory(self, j):
     def InventoryAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
     def InventoryLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -128,7 +132,9 @@ def Test4(self, j):
     def Test4Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -148,7 +154,9 @@ def Testarrayofstring(self, j):
     def TestarrayofstringLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -175,7 +183,9 @@ def Testarrayoftables(self, j):
     def TestarrayoftablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -206,7 +216,9 @@ def Testnestedflatbuffer(self, j):
     def TestnestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
@@ -221,7 +233,9 @@ def TestnestedflatbufferNestedRoot(self):
     def TestnestedflatbufferLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -315,14 +329,18 @@ def Testarrayofbools(self, j):
     def TestarrayofboolsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
+
         return 0
 
     # Monster
     def TestarrayofboolsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -363,7 +381,9 @@ def Testarrayofstring2(self, j):
     def Testarrayofstring2Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -387,7 +407,9 @@ def Testarrayofsortedstruct(self, j):
     def TestarrayofsortedstructLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -407,14 +429,18 @@ def Flex(self, j):
     def FlexAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
     def FlexLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -438,7 +464,9 @@ def Test5(self, j):
     def Test5Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -458,14 +486,18 @@ def VectorOfLongs(self, j):
     def VectorOfLongsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfLongsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -485,14 +517,18 @@ def VectorOfDoubles(self, j):
     def VectorOfDoublesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfDoublesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -528,7 +564,9 @@ def VectorOfReferrables(self, j):
     def VectorOfReferrablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -555,14 +593,18 @@ def VectorOfWeakReferences(self, j):
     def VectorOfWeakReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfWeakReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -587,7 +629,9 @@ def VectorOfStrongReferrables(self, j):
     def VectorOfStrongReferrablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -614,14 +658,18 @@ def VectorOfCoOwningReferences(self, j):
     def VectorOfCoOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfCoOwningReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -648,14 +696,18 @@ def VectorOfNonOwningReferences(self, j):
     def VectorOfNonOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfNonOwningReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -709,14 +761,18 @@ def VectorOfEnums(self, j):
     def VectorOfEnumsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
     def VectorOfEnumsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -743,7 +799,9 @@ def Testrequirednestedflatbuffer(self, j):
     def TestrequirednestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
@@ -758,7 +816,9 @@ def TestrequirednestedflatbufferNestedRoot(self):
     def TestrequirednestedflatbufferLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -783,7 +843,9 @@ def ScalarKeySortedTables(self, j):
     def ScalarKeySortedTablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1131,8 +1193,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         monster = Monster()
-        monster.Init(buf, pos)
+        monster.Init(buf, pos+n)
         return cls.InitFromObj(monster)
 
     @classmethod
diff --git a/tests/MyGame/Example/NestedStruct.py b/tests/MyGame/Example/NestedStruct.py
index a9db014f9ac..7ba4e1e0b51 100644
--- a/tests/MyGame/Example/NestedStruct.py
+++ b/tests/MyGame/Example/NestedStruct.py
@@ -18,48 +18,60 @@ def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # NestedStruct
-    def A(self): return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 4)) for i in range(2)]
+    def A(self, j = None):
+        if j==None:
+            return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 4)) for i in range(2)]
+        else:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + j * 4))
+    # NestedStruct
+    def AAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 0, 2)
+
     # NestedStruct
     def ALength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(0))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
+        return 2
 
     # NestedStruct
     def AIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(0))
-        return o == 0
+        return False
 
     # NestedStruct
     def B(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8))
     # NestedStruct
-    def C(self): return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + i * 1)) for i in range(2)]
+    def C(self, j = None):
+        if j==None:
+            return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + i * 1)) for i in range(2)]
+        else:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + j * 1))
+    # NestedStruct
+    def CAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int8Flags, self._tab.Pos + 9, 2)
+
     # NestedStruct
     def CLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(9))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
+        return 2
 
     # NestedStruct
     def CIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(9))
-        return o == 0
+        return False
 
     # NestedStruct
-    def D(self): return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + i * 8)) for i in range(2)]
+    def D(self, j = None):
+        if j==None:
+            return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + i * 8)) for i in range(2)]
+        else:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + j * 8))
+    # NestedStruct
+    def DAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 16, 2)
+
     # NestedStruct
     def DLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        return 0
+        return 2
 
     # NestedStruct
     def DIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
-        return o == 0
+        return False
 
 
 def CreateNestedStruct(builder, a, b, c, d):
@@ -90,8 +102,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         nestedStruct = NestedStruct()
-        nestedStruct.Init(buf, pos)
+        nestedStruct.Init(buf, pos+n)
         return cls.InitFromObj(nestedStruct)
 
     @classmethod
diff --git a/tests/MyGame/Example/Referrable.py b/tests/MyGame/Example/Referrable.py
index 4b1da6ae45e..8bf6ceba36f 100644
--- a/tests/MyGame/Example/Referrable.py
+++ b/tests/MyGame/Example/Referrable.py
@@ -53,8 +53,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         referrable = Referrable()
-        referrable.Init(buf, pos)
+        referrable.Init(buf, pos+n)
         return cls.InitFromObj(referrable)
 
     @classmethod
diff --git a/tests/MyGame/Example/Stat.py b/tests/MyGame/Example/Stat.py
index 3b19a3b849a..7845eb3df73 100644
--- a/tests/MyGame/Example/Stat.py
+++ b/tests/MyGame/Example/Stat.py
@@ -75,8 +75,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         stat = Stat()
-        stat.Init(buf, pos)
+        stat.Init(buf, pos+n)
         return cls.InitFromObj(stat)
 
     @classmethod
diff --git a/tests/MyGame/Example/StructOfStructs.py b/tests/MyGame/Example/StructOfStructs.py
index 0dcf3d5585a..f12ca5e611b 100644
--- a/tests/MyGame/Example/StructOfStructs.py
+++ b/tests/MyGame/Example/StructOfStructs.py
@@ -64,8 +64,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         structOfStructs = StructOfStructs()
-        structOfStructs.Init(buf, pos)
+        structOfStructs.Init(buf, pos+n)
         return cls.InitFromObj(structOfStructs)
 
     @classmethod
diff --git a/tests/MyGame/Example/StructOfStructsOfStructs.py b/tests/MyGame/Example/StructOfStructsOfStructs.py
index edba9821522..afef10ea7fc 100644
--- a/tests/MyGame/Example/StructOfStructsOfStructs.py
+++ b/tests/MyGame/Example/StructOfStructsOfStructs.py
@@ -52,8 +52,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         structOfStructsOfStructs = StructOfStructsOfStructs()
-        structOfStructsOfStructs.Init(buf, pos)
+        structOfStructsOfStructs.Init(buf, pos+n)
         return cls.InitFromObj(structOfStructsOfStructs)
 
     @classmethod
diff --git a/tests/MyGame/Example/Test.py b/tests/MyGame/Example/Test.py
index 8357ec209c0..17a71b82a8d 100644
--- a/tests/MyGame/Example/Test.py
+++ b/tests/MyGame/Example/Test.py
@@ -39,8 +39,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         test = Test()
-        test.Init(buf, pos)
+        test.Init(buf, pos+n)
         return cls.InitFromObj(test)
 
     @classmethod
diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.py b/tests/MyGame/Example/TestSimpleTableWithEnum.py
index 7f18ed24e53..7caf78f3c18 100644
--- a/tests/MyGame/Example/TestSimpleTableWithEnum.py
+++ b/tests/MyGame/Example/TestSimpleTableWithEnum.py
@@ -53,8 +53,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         testSimpleTableWithEnum = TestSimpleTableWithEnum()
-        testSimpleTableWithEnum.Init(buf, pos)
+        testSimpleTableWithEnum.Init(buf, pos+n)
         return cls.InitFromObj(testSimpleTableWithEnum)
 
     @classmethod
diff --git a/tests/MyGame/Example/TypeAliases.py b/tests/MyGame/Example/TypeAliases.py
index 8b0ea19c5be..4fc57fd4240 100644
--- a/tests/MyGame/Example/TypeAliases.py
+++ b/tests/MyGame/Example/TypeAliases.py
@@ -110,14 +110,18 @@ def V8(self, j):
     def V8AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+
         return 0
 
     # TypeAliases
     def V8Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # TypeAliases
@@ -137,14 +141,18 @@ def Vf64(self, j):
     def Vf64AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+
         return 0
 
     # TypeAliases
     def Vf64Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # TypeAliases
@@ -224,8 +232,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         typeAliases = TypeAliases()
-        typeAliases.Init(buf, pos)
+        typeAliases.Init(buf, pos+n)
         return cls.InitFromObj(typeAliases)
 
     @classmethod
diff --git a/tests/MyGame/Example/Vec3.py b/tests/MyGame/Example/Vec3.py
index 69cd511f43b..c0a44a81d53 100644
--- a/tests/MyGame/Example/Vec3.py
+++ b/tests/MyGame/Example/Vec3.py
@@ -68,8 +68,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         vec3 = Vec3()
-        vec3.Init(buf, pos)
+        vec3.Init(buf, pos+n)
         return cls.InitFromObj(vec3)
 
     @classmethod
diff --git a/tests/MyGame/Example2/Monster.py b/tests/MyGame/Example2/Monster.py
index 893ea9bbb47..fda0a0417ae 100644
--- a/tests/MyGame/Example2/Monster.py
+++ b/tests/MyGame/Example2/Monster.py
@@ -43,8 +43,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         monster = Monster()
-        monster.Init(buf, pos)
+        monster.Init(buf, pos+n)
         return cls.InitFromObj(monster)
 
     @classmethod
diff --git a/tests/MyGame/InParentNamespace.py b/tests/MyGame/InParentNamespace.py
index 197072b8437..807133d6a90 100644
--- a/tests/MyGame/InParentNamespace.py
+++ b/tests/MyGame/InParentNamespace.py
@@ -43,8 +43,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         inParentNamespace = InParentNamespace()
-        inParentNamespace.Init(buf, pos)
+        inParentNamespace.Init(buf, pos+n)
         return cls.InitFromObj(inParentNamespace)
 
     @classmethod
diff --git a/tests/MyGame/MonsterExtra.py b/tests/MyGame/MonsterExtra.py
index f7288b6c97b..45ccb5008d9 100644
--- a/tests/MyGame/MonsterExtra.py
+++ b/tests/MyGame/MonsterExtra.py
@@ -96,14 +96,18 @@ def Dvec(self, j):
     def DvecAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+
         return 0
 
     # MonsterExtra
     def DvecLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # MonsterExtra
@@ -123,14 +127,18 @@ def Fvec(self, j):
     def FvecAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
+
         return 0
 
     # MonsterExtra
     def FvecLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # MonsterExtra
@@ -202,8 +210,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         monsterExtra = MonsterExtra()
-        monsterExtra.Init(buf, pos)
+        monsterExtra.Init(buf, pos+n)
         return cls.InitFromObj(monsterExtra)
 
     @classmethod
diff --git a/tests/monster_test_generated.py b/tests/monster_test_generated.py
index 0fa2140560e..a950f2525fa 100644
--- a/tests/monster_test_generated.py
+++ b/tests/monster_test_generated.py
@@ -120,8 +120,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         inParentNamespace = InParentNamespace()
-        inParentNamespace.Init(buf, pos)
+        inParentNamespace.Init(buf, pos+n)
         return cls.InitFromObj(inParentNamespace)
 
     @classmethod
@@ -176,8 +177,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         monster = Monster()
-        monster.Init(buf, pos)
+        monster.Init(buf, pos+n)
         return cls.InitFromObj(monster)
 
     @classmethod
@@ -231,8 +233,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         test = Test()
-        test.Init(buf, pos)
+        test.Init(buf, pos+n)
         return cls.InitFromObj(test)
 
     @classmethod
@@ -295,8 +298,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         testSimpleTableWithEnum = TestSimpleTableWithEnum()
-        testSimpleTableWithEnum.Init(buf, pos)
+        testSimpleTableWithEnum.Init(buf, pos+n)
         return cls.InitFromObj(testSimpleTableWithEnum)
 
     @classmethod
@@ -380,8 +384,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         vec3 = Vec3()
-        vec3.Init(buf, pos)
+        vec3.Init(buf, pos+n)
         return cls.InitFromObj(vec3)
 
     @classmethod
@@ -439,8 +444,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         ability = Ability()
-        ability.Init(buf, pos)
+        ability.Init(buf, pos+n)
         return cls.InitFromObj(ability)
 
     @classmethod
@@ -517,8 +523,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         structOfStructs = StructOfStructs()
-        structOfStructs.Init(buf, pos)
+        structOfStructs.Init(buf, pos+n)
         return cls.InitFromObj(structOfStructs)
 
     @classmethod
@@ -588,8 +595,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         structOfStructsOfStructs = StructOfStructsOfStructs()
-        structOfStructsOfStructs.Init(buf, pos)
+        structOfStructsOfStructs.Init(buf, pos+n)
         return cls.InitFromObj(structOfStructsOfStructs)
 
     @classmethod
@@ -670,8 +678,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         stat = Stat()
-        stat.Init(buf, pos)
+        stat.Init(buf, pos+n)
         return cls.InitFromObj(stat)
 
     @classmethod
@@ -743,8 +752,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         referrable = Referrable()
-        referrable.Init(buf, pos)
+        referrable.Init(buf, pos+n)
         return cls.InitFromObj(referrable)
 
     @classmethod
@@ -833,14 +843,18 @@ def Inventory(self, j):
     def InventoryAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
     def InventoryLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -887,7 +901,9 @@ def Test4(self, j):
     def Test4Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -907,7 +923,9 @@ def Testarrayofstring(self, j):
     def TestarrayofstringLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -933,7 +951,9 @@ def Testarrayoftables(self, j):
     def TestarrayoftablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -963,7 +983,9 @@ def Testnestedflatbuffer(self, j):
     def TestnestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
@@ -978,7 +1000,9 @@ def TestnestedflatbufferNestedRoot(self):
     def TestnestedflatbufferLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1071,14 +1095,18 @@ def Testarrayofbools(self, j):
     def TestarrayofboolsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
+
         return 0
 
     # Monster
     def TestarrayofboolsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1119,7 +1147,9 @@ def Testarrayofstring2(self, j):
     def Testarrayofstring2Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1142,7 +1172,9 @@ def Testarrayofsortedstruct(self, j):
     def TestarrayofsortedstructLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1162,14 +1194,18 @@ def Flex(self, j):
     def FlexAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
     def FlexLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1192,7 +1228,9 @@ def Test5(self, j):
     def Test5Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1212,14 +1250,18 @@ def VectorOfLongs(self, j):
     def VectorOfLongsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfLongsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1239,14 +1281,18 @@ def VectorOfDoubles(self, j):
     def VectorOfDoublesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfDoublesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1280,7 +1326,9 @@ def VectorOfReferrables(self, j):
     def VectorOfReferrablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1307,14 +1355,18 @@ def VectorOfWeakReferences(self, j):
     def VectorOfWeakReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfWeakReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1338,7 +1390,9 @@ def VectorOfStrongReferrables(self, j):
     def VectorOfStrongReferrablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1365,14 +1419,18 @@ def VectorOfCoOwningReferences(self, j):
     def VectorOfCoOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfCoOwningReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1399,14 +1457,18 @@ def VectorOfNonOwningReferences(self, j):
     def VectorOfNonOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+
         return 0
 
     # Monster
     def VectorOfNonOwningReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1460,14 +1522,18 @@ def VectorOfEnums(self, j):
     def VectorOfEnumsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
     def VectorOfEnumsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1494,7 +1560,9 @@ def Testrequirednestedflatbuffer(self, j):
     def TestrequirednestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+
         return 0
 
     # Monster
@@ -1509,7 +1577,9 @@ def TestrequirednestedflatbufferNestedRoot(self):
     def TestrequirednestedflatbufferLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1533,7 +1603,9 @@ def ScalarKeySortedTables(self, j):
     def ScalarKeySortedTablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # Monster
@@ -1716,8 +1788,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         monster = Monster()
-        monster.Init(buf, pos)
+        monster.Init(buf, pos+n)
         return cls.InitFromObj(monster)
 
     @classmethod
@@ -2270,14 +2343,18 @@ def V8(self, j):
     def V8AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+
         return 0
 
     # TypeAliases
     def V8Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # TypeAliases
@@ -2297,14 +2374,18 @@ def Vf64(self, j):
     def Vf64AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
+
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+
         return 0
 
     # TypeAliases
     def Vf64Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
+
             return self._tab.VectorLen(o)
+
         return 0
 
     # TypeAliases
@@ -2353,8 +2434,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         typeAliases = TypeAliases()
-        typeAliases.Init(buf, pos)
+        typeAliases.Init(buf, pos+n)
         return cls.InitFromObj(typeAliases)
 
     @classmethod
diff --git a/tests/optional_scalars/ScalarStuff.py b/tests/optional_scalars/ScalarStuff.py
index 4dea123be93..3e7d2a221b6 100644
--- a/tests/optional_scalars/ScalarStuff.py
+++ b/tests/optional_scalars/ScalarStuff.py
@@ -438,8 +438,9 @@ def __init__(self):
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)
         scalarStuff = ScalarStuff()
-        scalarStuff.Init(buf, pos)
+        scalarStuff.Init(buf, pos+n)
         return cls.InitFromObj(scalarStuff)
 
     @classmethod
diff --git a/tests/py_test.py b/tests/py_test.py
index 390c93b7914..1332257fdc7 100644
--- a/tests/py_test.py
+++ b/tests/py_test.py
@@ -2658,6 +2658,10 @@ def test_fixed_length_array(self):
     self.assertEqual(table.A().D(1).D(), [-2, 2])
     self.assertEqual(table.A().E(), 2)
     self.assertEqual(table.A().F(), [-1, 1])
+    self.assertEqual(table.A().D(0).D(0), -1)
+    self.assertEqual(table.A().D(0).D(1), 1)
+    self.assertEqual(table.A().D(1).D(0), -2)
+    self.assertEqual(table.A().D(1).D(1), 2)
 
 def CheckAgainstGoldDataGo():
   try:

From f05af7ab80c574ca8d7be07492619201328afe8b Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Thu, 15 Sep 2022 10:50:09 +0100
Subject: [PATCH 06/10] Added new_line parameter to OffsetPrefix to allow
 optional new lines to be added. This allows us to use the GenIndents method
 that automatically adds new lines instead.

---
 src/idl_gen_python.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 100bdeff51a..97cff8dff71 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -17,7 +17,6 @@
 // independent from idl_parser, since this code is not needed for most clients
 
 #include <cctype>
-#include <iostream>
 #include <set>
 #include <string>
 #include <unordered_set>
@@ -84,11 +83,11 @@ class PythonGenerator : public BaseGenerator {
 
   // Most field accessors need to retrieve and test the field offset first,
   // this is the prefix code for that.
-  std::string OffsetPrefix(const FieldDef &field) const {
+  std::string OffsetPrefix(const FieldDef &field, bool new_line = true) const {
     return "\n" + Indent + Indent +
            "o = flatbuffers.number_types.UOffsetTFlags.py_type" +
            "(self._tab.Offset(" + NumToString(field.value.offset) + "))\n" +
-           Indent + Indent + "if o != 0:\n";
+           Indent + Indent + "if o != 0:" + (new_line ? "\n" : "");
   }
 
   // Begin a class declaration.
@@ -167,8 +166,8 @@ class PythonGenerator : public BaseGenerator {
     code += namer_.Method(field) + "Length(self";
     code += "):";
     if(!IsArray(field.value.type)){
-      code += OffsetPrefix(field);
-      code += GenIndents(3) + "return self._tab.VectorLen(o)\n";
+      code += OffsetPrefix(field,false);
+      code += GenIndents(3) + "return self._tab.VectorLen(o)";
       code += GenIndents(2) + "return 0\n\n";
     }else{
       code += GenIndents(2) + "return "+NumToString(field.value.type.fixed_length)+"\n\n";
@@ -434,7 +433,7 @@ class PythonGenerator : public BaseGenerator {
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field) + "AsNumpy(self):";
     if(!IsArray(field.value.type)){
-      code += OffsetPrefix(field);
+      code += OffsetPrefix(field, false);
 
       code += GenIndents(3);
       code += "return ";

From 26b0eb861004d185a6e0fd1b8911535cdd525365 Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Thu, 15 Sep 2022 10:53:25 +0100
Subject: [PATCH 07/10] Reupload of generated code from the
 scripts/generate_code.py

---
 python/flatbuffers/reflection/Enum.py       |  6 ---
 python/flatbuffers/reflection/EnumVal.py    |  2 -
 python/flatbuffers/reflection/Field.py      |  4 --
 python/flatbuffers/reflection/Object.py     |  6 ---
 python/flatbuffers/reflection/RPCCall.py    |  4 --
 python/flatbuffers/reflection/Schema.py     |  8 ---
 python/flatbuffers/reflection/SchemaFile.py |  2 -
 python/flatbuffers/reflection/Service.py    |  6 ---
 tests/MyGame/Example/Monster.py             | 51 ------------------
 tests/MyGame/Example/TypeAliases.py         |  6 ---
 tests/MyGame/MonsterExtra.py                |  6 ---
 tests/monster_test_generated.py             | 57 ---------------------
 12 files changed, 158 deletions(-)

diff --git a/python/flatbuffers/reflection/Enum.py b/python/flatbuffers/reflection/Enum.py
index fe80f3bdff8..b27e4102c21 100644
--- a/python/flatbuffers/reflection/Enum.py
+++ b/python/flatbuffers/reflection/Enum.py
@@ -52,9 +52,7 @@ def Values(self, j):
     def ValuesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Enum
@@ -97,9 +95,7 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Enum
@@ -119,9 +115,7 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Enum
diff --git a/python/flatbuffers/reflection/EnumVal.py b/python/flatbuffers/reflection/EnumVal.py
index 67b1b8d967a..62a32dc7f02 100644
--- a/python/flatbuffers/reflection/EnumVal.py
+++ b/python/flatbuffers/reflection/EnumVal.py
@@ -65,9 +65,7 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # EnumVal
diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py
index 3a9bce55158..01b52808a1f 100644
--- a/python/flatbuffers/reflection/Field.py
+++ b/python/flatbuffers/reflection/Field.py
@@ -112,9 +112,7 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Field
@@ -134,9 +132,7 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Field
diff --git a/python/flatbuffers/reflection/Object.py b/python/flatbuffers/reflection/Object.py
index 53f3597fcd5..598927c8af6 100644
--- a/python/flatbuffers/reflection/Object.py
+++ b/python/flatbuffers/reflection/Object.py
@@ -52,9 +52,7 @@ def Fields(self, j):
     def FieldsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Object
@@ -100,9 +98,7 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Object
@@ -122,9 +118,7 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Object
diff --git a/python/flatbuffers/reflection/RPCCall.py b/python/flatbuffers/reflection/RPCCall.py
index 8c73758ed62..9fdbf468b8f 100644
--- a/python/flatbuffers/reflection/RPCCall.py
+++ b/python/flatbuffers/reflection/RPCCall.py
@@ -74,9 +74,7 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # RPCCall
@@ -96,9 +94,7 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # RPCCall
diff --git a/python/flatbuffers/reflection/Schema.py b/python/flatbuffers/reflection/Schema.py
index 6bd4f32af55..df2f072f985 100644
--- a/python/flatbuffers/reflection/Schema.py
+++ b/python/flatbuffers/reflection/Schema.py
@@ -45,9 +45,7 @@ def Objects(self, j):
     def ObjectsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Schema
@@ -72,9 +70,7 @@ def Enums(self, j):
     def EnumsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Schema
@@ -124,9 +120,7 @@ def Services(self, j):
     def ServicesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Schema
@@ -160,9 +154,7 @@ def FbsFiles(self, j):
     def FbsFilesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Schema
diff --git a/python/flatbuffers/reflection/SchemaFile.py b/python/flatbuffers/reflection/SchemaFile.py
index 003ed24fc85..890fd3b5308 100644
--- a/python/flatbuffers/reflection/SchemaFile.py
+++ b/python/flatbuffers/reflection/SchemaFile.py
@@ -52,9 +52,7 @@ def IncludedFilenames(self, j):
     def IncludedFilenamesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # SchemaFile
diff --git a/python/flatbuffers/reflection/Service.py b/python/flatbuffers/reflection/Service.py
index 3f242aa5390..d4f1a6a8ea6 100644
--- a/python/flatbuffers/reflection/Service.py
+++ b/python/flatbuffers/reflection/Service.py
@@ -52,9 +52,7 @@ def Calls(self, j):
     def CallsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Service
@@ -79,9 +77,7 @@ def Attributes(self, j):
     def AttributesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Service
@@ -101,9 +97,7 @@ def Documentation(self, j):
     def DocumentationLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Service
diff --git a/tests/MyGame/Example/Monster.py b/tests/MyGame/Example/Monster.py
index 95b8e2ecddc..9a04c4c8981 100644
--- a/tests/MyGame/Example/Monster.py
+++ b/tests/MyGame/Example/Monster.py
@@ -73,7 +73,6 @@ def Inventory(self, j):
     def InventoryAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -82,9 +81,7 @@ def InventoryAsNumpy(self):
     def InventoryLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -132,9 +129,7 @@ def Test4(self, j):
     def Test4Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -154,9 +149,7 @@ def Testarrayofstring(self, j):
     def TestarrayofstringLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -183,9 +176,7 @@ def Testarrayoftables(self, j):
     def TestarrayoftablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -216,7 +207,6 @@ def Testnestedflatbuffer(self, j):
     def TestnestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -233,9 +223,7 @@ def TestnestedflatbufferNestedRoot(self):
     def TestnestedflatbufferLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -329,7 +317,6 @@ def Testarrayofbools(self, j):
     def TestarrayofboolsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
 
         return 0
@@ -338,9 +325,7 @@ def TestarrayofboolsAsNumpy(self):
     def TestarrayofboolsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -381,9 +366,7 @@ def Testarrayofstring2(self, j):
     def Testarrayofstring2Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -407,9 +390,7 @@ def Testarrayofsortedstruct(self, j):
     def TestarrayofsortedstructLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -429,7 +410,6 @@ def Flex(self, j):
     def FlexAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -438,9 +418,7 @@ def FlexAsNumpy(self):
     def FlexLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -464,9 +442,7 @@ def Test5(self, j):
     def Test5Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -486,7 +462,6 @@ def VectorOfLongs(self, j):
     def VectorOfLongsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
 
         return 0
@@ -495,9 +470,7 @@ def VectorOfLongsAsNumpy(self):
     def VectorOfLongsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -517,7 +490,6 @@ def VectorOfDoubles(self, j):
     def VectorOfDoublesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
 
         return 0
@@ -526,9 +498,7 @@ def VectorOfDoublesAsNumpy(self):
     def VectorOfDoublesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -564,9 +534,7 @@ def VectorOfReferrables(self, j):
     def VectorOfReferrablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -593,7 +561,6 @@ def VectorOfWeakReferences(self, j):
     def VectorOfWeakReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
 
         return 0
@@ -602,9 +569,7 @@ def VectorOfWeakReferencesAsNumpy(self):
     def VectorOfWeakReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -629,9 +594,7 @@ def VectorOfStrongReferrables(self, j):
     def VectorOfStrongReferrablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -658,7 +621,6 @@ def VectorOfCoOwningReferences(self, j):
     def VectorOfCoOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
 
         return 0
@@ -667,9 +629,7 @@ def VectorOfCoOwningReferencesAsNumpy(self):
     def VectorOfCoOwningReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -696,7 +656,6 @@ def VectorOfNonOwningReferences(self, j):
     def VectorOfNonOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
 
         return 0
@@ -705,9 +664,7 @@ def VectorOfNonOwningReferencesAsNumpy(self):
     def VectorOfNonOwningReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -761,7 +718,6 @@ def VectorOfEnums(self, j):
     def VectorOfEnumsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -770,9 +726,7 @@ def VectorOfEnumsAsNumpy(self):
     def VectorOfEnumsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -799,7 +753,6 @@ def Testrequirednestedflatbuffer(self, j):
     def TestrequirednestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -816,9 +769,7 @@ def TestrequirednestedflatbufferNestedRoot(self):
     def TestrequirednestedflatbufferLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -843,9 +794,7 @@ def ScalarKeySortedTables(self, j):
     def ScalarKeySortedTablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
diff --git a/tests/MyGame/Example/TypeAliases.py b/tests/MyGame/Example/TypeAliases.py
index 4fc57fd4240..25bd6a58a56 100644
--- a/tests/MyGame/Example/TypeAliases.py
+++ b/tests/MyGame/Example/TypeAliases.py
@@ -110,7 +110,6 @@ def V8(self, j):
     def V8AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
 
         return 0
@@ -119,9 +118,7 @@ def V8AsNumpy(self):
     def V8Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # TypeAliases
@@ -141,7 +138,6 @@ def Vf64(self, j):
     def Vf64AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
 
         return 0
@@ -150,9 +146,7 @@ def Vf64AsNumpy(self):
     def Vf64Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # TypeAliases
diff --git a/tests/MyGame/MonsterExtra.py b/tests/MyGame/MonsterExtra.py
index 45ccb5008d9..a1ea629f80b 100644
--- a/tests/MyGame/MonsterExtra.py
+++ b/tests/MyGame/MonsterExtra.py
@@ -96,7 +96,6 @@ def Dvec(self, j):
     def DvecAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
 
         return 0
@@ -105,9 +104,7 @@ def DvecAsNumpy(self):
     def DvecLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # MonsterExtra
@@ -127,7 +124,6 @@ def Fvec(self, j):
     def FvecAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
 
         return 0
@@ -136,9 +132,7 @@ def FvecAsNumpy(self):
     def FvecLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # MonsterExtra
diff --git a/tests/monster_test_generated.py b/tests/monster_test_generated.py
index a950f2525fa..b430eb55c8a 100644
--- a/tests/monster_test_generated.py
+++ b/tests/monster_test_generated.py
@@ -843,7 +843,6 @@ def Inventory(self, j):
     def InventoryAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -852,9 +851,7 @@ def InventoryAsNumpy(self):
     def InventoryLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -901,9 +898,7 @@ def Test4(self, j):
     def Test4Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -923,9 +918,7 @@ def Testarrayofstring(self, j):
     def TestarrayofstringLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -951,9 +944,7 @@ def Testarrayoftables(self, j):
     def TestarrayoftablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -983,7 +974,6 @@ def Testnestedflatbuffer(self, j):
     def TestnestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -1000,9 +990,7 @@ def TestnestedflatbufferNestedRoot(self):
     def TestnestedflatbufferLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1095,7 +1083,6 @@ def Testarrayofbools(self, j):
     def TestarrayofboolsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
 
         return 0
@@ -1104,9 +1091,7 @@ def TestarrayofboolsAsNumpy(self):
     def TestarrayofboolsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1147,9 +1132,7 @@ def Testarrayofstring2(self, j):
     def Testarrayofstring2Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1172,9 +1155,7 @@ def Testarrayofsortedstruct(self, j):
     def TestarrayofsortedstructLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1194,7 +1175,6 @@ def Flex(self, j):
     def FlexAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -1203,9 +1183,7 @@ def FlexAsNumpy(self):
     def FlexLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1228,9 +1206,7 @@ def Test5(self, j):
     def Test5Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1250,7 +1226,6 @@ def VectorOfLongs(self, j):
     def VectorOfLongsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
 
         return 0
@@ -1259,9 +1234,7 @@ def VectorOfLongsAsNumpy(self):
     def VectorOfLongsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1281,7 +1254,6 @@ def VectorOfDoubles(self, j):
     def VectorOfDoublesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
 
         return 0
@@ -1290,9 +1262,7 @@ def VectorOfDoublesAsNumpy(self):
     def VectorOfDoublesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1326,9 +1296,7 @@ def VectorOfReferrables(self, j):
     def VectorOfReferrablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1355,7 +1323,6 @@ def VectorOfWeakReferences(self, j):
     def VectorOfWeakReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
 
         return 0
@@ -1364,9 +1331,7 @@ def VectorOfWeakReferencesAsNumpy(self):
     def VectorOfWeakReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1390,9 +1355,7 @@ def VectorOfStrongReferrables(self, j):
     def VectorOfStrongReferrablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1419,7 +1382,6 @@ def VectorOfCoOwningReferences(self, j):
     def VectorOfCoOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
 
         return 0
@@ -1428,9 +1390,7 @@ def VectorOfCoOwningReferencesAsNumpy(self):
     def VectorOfCoOwningReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1457,7 +1417,6 @@ def VectorOfNonOwningReferences(self, j):
     def VectorOfNonOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
 
         return 0
@@ -1466,9 +1425,7 @@ def VectorOfNonOwningReferencesAsNumpy(self):
     def VectorOfNonOwningReferencesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1522,7 +1479,6 @@ def VectorOfEnums(self, j):
     def VectorOfEnumsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -1531,9 +1487,7 @@ def VectorOfEnumsAsNumpy(self):
     def VectorOfEnumsLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1560,7 +1514,6 @@ def Testrequirednestedflatbuffer(self, j):
     def TestrequirednestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 
         return 0
@@ -1577,9 +1530,7 @@ def TestrequirednestedflatbufferNestedRoot(self):
     def TestrequirednestedflatbufferLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -1603,9 +1554,7 @@ def ScalarKeySortedTables(self, j):
     def ScalarKeySortedTablesLength(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # Monster
@@ -2343,7 +2292,6 @@ def V8(self, j):
     def V8AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
 
         return 0
@@ -2352,9 +2300,7 @@ def V8AsNumpy(self):
     def V8Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # TypeAliases
@@ -2374,7 +2320,6 @@ def Vf64(self, j):
     def Vf64AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
 
         return 0
@@ -2383,9 +2328,7 @@ def Vf64AsNumpy(self):
     def Vf64Length(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-
             return self._tab.VectorLen(o)
-
         return 0
 
     # TypeAliases

From 3818348e4ca0fdd7515ce3b2b415323bd0dd057c Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Thu, 15 Sep 2022 10:57:03 +0100
Subject: [PATCH 08/10] Removed new line in GetVectorAsNumpy.

---
 src/idl_gen_python.cpp              |  2 +-
 tests/MyGame/Example/Monster.py     | 11 -----------
 tests/MyGame/Example/TypeAliases.py |  2 --
 tests/MyGame/MonsterExtra.py        |  2 --
 tests/monster_test_generated.py     | 13 -------------
 5 files changed, 1 insertion(+), 29 deletions(-)

diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 97cff8dff71..7c81e23d542 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -439,7 +439,7 @@ class PythonGenerator : public BaseGenerator {
       code += "return ";
       code += "self._tab.GetVectorAsNumpy(flatbuffers.number_types.";
       code += namer_.Method(GenTypeGet(field.value.type));
-      code += "Flags, o)\n";
+      code += "Flags, o)";
 
       if (IsString(vectortype)) {
         code += GenIndents(2) + "return \"\"\n";
diff --git a/tests/MyGame/Example/Monster.py b/tests/MyGame/Example/Monster.py
index 9a04c4c8981..654fdcbe3b5 100644
--- a/tests/MyGame/Example/Monster.py
+++ b/tests/MyGame/Example/Monster.py
@@ -74,7 +74,6 @@ def InventoryAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -208,7 +207,6 @@ def TestnestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -318,7 +316,6 @@ def TestarrayofboolsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
-
         return 0
 
     # Monster
@@ -411,7 +408,6 @@ def FlexAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -463,7 +459,6 @@ def VectorOfLongsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
-
         return 0
 
     # Monster
@@ -491,7 +486,6 @@ def VectorOfDoublesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
-
         return 0
 
     # Monster
@@ -562,7 +556,6 @@ def VectorOfWeakReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
-
         return 0
 
     # Monster
@@ -622,7 +615,6 @@ def VectorOfCoOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
-
         return 0
 
     # Monster
@@ -657,7 +649,6 @@ def VectorOfNonOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
-
         return 0
 
     # Monster
@@ -719,7 +710,6 @@ def VectorOfEnumsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -754,7 +744,6 @@ def TestrequirednestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
diff --git a/tests/MyGame/Example/TypeAliases.py b/tests/MyGame/Example/TypeAliases.py
index 25bd6a58a56..6f08bd8cb50 100644
--- a/tests/MyGame/Example/TypeAliases.py
+++ b/tests/MyGame/Example/TypeAliases.py
@@ -111,7 +111,6 @@ def V8AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
-
         return 0
 
     # TypeAliases
@@ -139,7 +138,6 @@ def Vf64AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
-
         return 0
 
     # TypeAliases
diff --git a/tests/MyGame/MonsterExtra.py b/tests/MyGame/MonsterExtra.py
index a1ea629f80b..4569b513f97 100644
--- a/tests/MyGame/MonsterExtra.py
+++ b/tests/MyGame/MonsterExtra.py
@@ -97,7 +97,6 @@ def DvecAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
-
         return 0
 
     # MonsterExtra
@@ -125,7 +124,6 @@ def FvecAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
-
         return 0
 
     # MonsterExtra
diff --git a/tests/monster_test_generated.py b/tests/monster_test_generated.py
index b430eb55c8a..27aff92dace 100644
--- a/tests/monster_test_generated.py
+++ b/tests/monster_test_generated.py
@@ -844,7 +844,6 @@ def InventoryAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -975,7 +974,6 @@ def TestnestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -1084,7 +1082,6 @@ def TestarrayofboolsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
-
         return 0
 
     # Monster
@@ -1176,7 +1173,6 @@ def FlexAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -1227,7 +1223,6 @@ def VectorOfLongsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
-
         return 0
 
     # Monster
@@ -1255,7 +1250,6 @@ def VectorOfDoublesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
-
         return 0
 
     # Monster
@@ -1324,7 +1318,6 @@ def VectorOfWeakReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
-
         return 0
 
     # Monster
@@ -1383,7 +1376,6 @@ def VectorOfCoOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
-
         return 0
 
     # Monster
@@ -1418,7 +1410,6 @@ def VectorOfNonOwningReferencesAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
-
         return 0
 
     # Monster
@@ -1480,7 +1471,6 @@ def VectorOfEnumsAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -1515,7 +1505,6 @@ def TestrequirednestedflatbufferAsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
-
         return 0
 
     # Monster
@@ -2293,7 +2282,6 @@ def V8AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
-
         return 0
 
     # TypeAliases
@@ -2321,7 +2309,6 @@ def Vf64AsNumpy(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
-
         return 0
 
     # TypeAliases

From 93086f06b5442e4057fc47659b5508f693ff9d69 Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Fri, 16 Sep 2022 15:03:58 +0100
Subject: [PATCH 09/10] Updated Array lengths to use Length methods where
 possible. Added fallthrough for GenTypePointer. Added digit check to
 CamelToSnake method. Added and modified tests for ToSnakeCase and
 CamelToSnake.

---
 src/idl_gen_python.cpp               |  7 ++++---
 src/util.cpp                         |  2 +-
 tests/MyGame/Example/ArrayStruct.py  |  8 ++++----
 tests/MyGame/Example/NestedStruct.py | 12 ++++++------
 tests/util_test.cpp                  | 10 +++++++++-
 5 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 7c81e23d542..06b8a8fb98a 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -281,7 +281,7 @@ class PythonGenerator : public BaseGenerator {
     code += NumToString(field.value.offset) + " + i * ";
     code += NumToString(InlineSize(field.value.type.VectorType()));
     code += ")) for i in range(";
-    code += NumToString(field.value.type.fixed_length) + ")]";
+    code += NumToString("self."+namer_.Method(field)+"Length()") + ")]";
     code += GenIndents(2) +"else:";
     code += GenIndents(3) + "return " + GenGetter(field.value.type);
     code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
@@ -450,7 +450,7 @@ class PythonGenerator : public BaseGenerator {
       code += GenIndents(2) + "return ";
       code += "self._tab.GetArrayAsNumpy(flatbuffers.number_types.";
       code += namer_.Method(GenTypeGet(field.value.type.VectorType()));
-      code += "Flags, self._tab.Pos + "+NumToString(field.value.offset)+", "+NumToString(field.value.type.VectorType().fixed_length)+")\n";
+      code += "Flags, self._tab.Pos + "+NumToString(field.value.offset)+", "+NumToString("self."+namer_.Method(field)+"Length()")+")\n";
     }
     code += "\n";
   }
@@ -1735,7 +1735,8 @@ class PythonGenerator : public BaseGenerator {
   std::string GenTypePointer(const Type &type) const {
     switch (type.base_type) {
       case BASE_TYPE_STRING: return "string";
-      case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType());
+      case BASE_TYPE_VECTOR:
+        // fall through
       case BASE_TYPE_ARRAY: return GenTypeGet(type.VectorType());
       case BASE_TYPE_STRUCT: return type.struct_def->name;
       case BASE_TYPE_UNION:
diff --git a/src/util.cpp b/src/util.cpp
index 454a2e3ed01..aabc23aa405 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -135,7 +135,7 @@ std::string CamelToSnake(const std::string &input) {
     } else if (!islower(input[i])) {
       // Prevent duplicate underscores for Upper_Snake_Case strings
       // and UPPERCASE strings.
-      if (islower(input[i - 1])) { s += '_'; }
+      if (islower(input[i - 1]) || (isdigit(input[i-1]) && !isdigit(input[i]))) { s += '_'; }
       s += CharToLower(input[i]);
     } else {
       s += input[i];
diff --git a/tests/MyGame/Example/ArrayStruct.py b/tests/MyGame/Example/ArrayStruct.py
index 6be8bac85ea..12589d8712c 100644
--- a/tests/MyGame/Example/ArrayStruct.py
+++ b/tests/MyGame/Example/ArrayStruct.py
@@ -22,12 +22,12 @@ def A(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._t
     # ArrayStruct
     def B(self, j = None):
         if j==None:
-            return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + i * 4)) for i in range(15)]
+            return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + i * 4)) for i in range(self.BLength())]
         else:
             return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + j * 4))
     # ArrayStruct
     def BAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 4, 15)
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 4, self.BLength())
 
     # ArrayStruct
     def BLength(self):
@@ -59,12 +59,12 @@ def E(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab
     # ArrayStruct
     def F(self, j = None):
         if j==None:
-            return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + i * 8)) for i in range(2)]
+            return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + i * 8)) for i in range(self.FLength())]
         else:
             return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + j * 8))
     # ArrayStruct
     def FAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 144, 2)
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 144, self.FLength())
 
     # ArrayStruct
     def FLength(self):
diff --git a/tests/MyGame/Example/NestedStruct.py b/tests/MyGame/Example/NestedStruct.py
index 7ba4e1e0b51..2c36f0b7933 100644
--- a/tests/MyGame/Example/NestedStruct.py
+++ b/tests/MyGame/Example/NestedStruct.py
@@ -20,12 +20,12 @@ def Init(self, buf, pos):
     # NestedStruct
     def A(self, j = None):
         if j==None:
-            return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 4)) for i in range(2)]
+            return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 4)) for i in range(self.ALength())]
         else:
             return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + j * 4))
     # NestedStruct
     def AAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 0, 2)
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 0, self.ALength())
 
     # NestedStruct
     def ALength(self):
@@ -40,12 +40,12 @@ def B(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.
     # NestedStruct
     def C(self, j = None):
         if j==None:
-            return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + i * 1)) for i in range(2)]
+            return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + i * 1)) for i in range(self.CLength())]
         else:
             return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + j * 1))
     # NestedStruct
     def CAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int8Flags, self._tab.Pos + 9, 2)
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int8Flags, self._tab.Pos + 9, self.CLength())
 
     # NestedStruct
     def CLength(self):
@@ -58,12 +58,12 @@ def CIsNone(self):
     # NestedStruct
     def D(self, j = None):
         if j==None:
-            return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + i * 8)) for i in range(2)]
+            return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + i * 8)) for i in range(self.DLength())]
         else:
             return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + j * 8))
     # NestedStruct
     def DAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 16, 2)
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 16, self.DLength())
 
     # NestedStruct
     def DLength(self):
diff --git a/tests/util_test.cpp b/tests/util_test.cpp
index d6db91673d7..f2821a40ce4 100644
--- a/tests/util_test.cpp
+++ b/tests/util_test.cpp
@@ -149,11 +149,19 @@ void UtilConvertCase() {
     cases.push_back({ flatbuffers::Case::kUpperCamel, "tHe_qUiCk_BrOwN_fOx",
                       flatbuffers::Case::kKeep, "tHe_qUiCk_BrOwN_fOx" });
     cases.push_back({ flatbuffers::Case::kLowerCamel, "theQuick12345Fox",
-                      flatbuffers::Case::kSnake, "the_quick_12345fox" });
+                      flatbuffers::Case::kSnake, "the_quick_12345_fox" });
     cases.push_back({ flatbuffers::Case::kLowerCamel, "a12b34c45",
                       flatbuffers::Case::kSnake, "a_12b_34c_45" });
     cases.push_back({ flatbuffers::Case::kLowerCamel, "a12b34c45",
                       flatbuffers::Case::kSnake2, "a12_b34_c45" });
+    cases.push_back({ flatbuffers::Case::kUpperCamel, "Int32Stamped",
+                      flatbuffers::Case::kSnake, "int_32_stamped" });
+    cases.push_back({ flatbuffers::Case::kUpperCamel, "101DogsTest",
+                      flatbuffers::Case::kSnake, "101_dogs_test" });
+    cases.push_back({ flatbuffers::Case::kUpperCamel, "Int32Stamped",
+                      flatbuffers::Case::kScreamingSnake, "INT_32_STAMPED" });
+    cases.push_back({ flatbuffers::Case::kUpperCamel, "101DogsTest",
+                      flatbuffers::Case::kScreamingSnake, "101_DOGS_TEST" });
 
     for (auto &test_case : cases) {
       TEST_EQ(test_case.expected_output,

From b627623a8ed9c5158a6ba7040159734bf2ce9eab Mon Sep 17 00:00:00 2001
From: Joshua Smith <joshua.smith8@ocado.com>
Date: Wed, 21 Sep 2022 11:30:43 +0100
Subject: [PATCH 10/10] Added range check on the getter methods for vector and
 array types. Renamed == as is for python

---
 src/idl_gen_python.cpp               | 10 ++++++----
 tests/MyGame/Example/ArrayStruct.py  | 14 ++++++++++----
 tests/MyGame/Example/NestedStruct.py | 21 +++++++++++++++------
 3 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 06b8a8fb98a..289b18691f1 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -275,19 +275,21 @@ class PythonGenerator : public BaseGenerator {
     GenReceiver(struct_def, code_ptr);
     code += namer_.Method(field);
     code += "(self, j = None):";
-    code += GenIndents(2) + "if j==None:";
+    code += GenIndents(2) + "if j is None:";
     code += GenIndents(3) + "return [" + GenGetter(field.value.type);
     code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
     code += NumToString(field.value.offset) + " + i * ";
     code += NumToString(InlineSize(field.value.type.VectorType()));
     code += ")) for i in range(";
-    code += NumToString("self."+namer_.Method(field)+"Length()") + ")]";
-    code += GenIndents(2) +"else:";
+    code += "self."+namer_.Method(field)+"Length()" + ")]";
+    code += GenIndents(2) +"elif j >= 0 and j < self."+namer_.Method(field)+"Length():";
     code += GenIndents(3) + "return " + GenGetter(field.value.type);
     code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";
     code += NumToString(field.value.offset) + " + j * ";
     code += NumToString(InlineSize(field.value.type.VectorType()));
-    code += "))\n";
+    code += "))";
+    code += GenIndents(2) + "else:";
+    code += GenIndents(3) + "return None\n\n";
   }
 
   // Get a struct by initializing an existing struct.
diff --git a/tests/MyGame/Example/ArrayStruct.py b/tests/MyGame/Example/ArrayStruct.py
index 12589d8712c..3b54cb23794 100644
--- a/tests/MyGame/Example/ArrayStruct.py
+++ b/tests/MyGame/Example/ArrayStruct.py
@@ -21,10 +21,13 @@ def Init(self, buf, pos):
     def A(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
     # ArrayStruct
     def B(self, j = None):
-        if j==None:
+        if j is None:
             return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + i * 4)) for i in range(self.BLength())]
-        else:
+        elif j >= 0 and j < self.BLength():
             return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + j * 4))
+        else:
+            return None
+
     # ArrayStruct
     def BAsNumpy(self):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 4, self.BLength())
@@ -58,10 +61,13 @@ def DIsNone(self):
     def E(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(136))
     # ArrayStruct
     def F(self, j = None):
-        if j==None:
+        if j is None:
             return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + i * 8)) for i in range(self.FLength())]
-        else:
+        elif j >= 0 and j < self.FLength():
             return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + j * 8))
+        else:
+            return None
+
     # ArrayStruct
     def FAsNumpy(self):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 144, self.FLength())
diff --git a/tests/MyGame/Example/NestedStruct.py b/tests/MyGame/Example/NestedStruct.py
index 2c36f0b7933..21065efae2c 100644
--- a/tests/MyGame/Example/NestedStruct.py
+++ b/tests/MyGame/Example/NestedStruct.py
@@ -19,10 +19,13 @@ def Init(self, buf, pos):
 
     # NestedStruct
     def A(self, j = None):
-        if j==None:
+        if j is None:
             return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 4)) for i in range(self.ALength())]
-        else:
+        elif j >= 0 and j < self.ALength():
             return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + j * 4))
+        else:
+            return None
+
     # NestedStruct
     def AAsNumpy(self):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int32Flags, self._tab.Pos + 0, self.ALength())
@@ -39,10 +42,13 @@ def AIsNone(self):
     def B(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8))
     # NestedStruct
     def C(self, j = None):
-        if j==None:
+        if j is None:
             return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + i * 1)) for i in range(self.CLength())]
-        else:
+        elif j >= 0 and j < self.CLength():
             return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + j * 1))
+        else:
+            return None
+
     # NestedStruct
     def CAsNumpy(self):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int8Flags, self._tab.Pos + 9, self.CLength())
@@ -57,10 +63,13 @@ def CIsNone(self):
 
     # NestedStruct
     def D(self, j = None):
-        if j==None:
+        if j is None:
             return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + i * 8)) for i in range(self.DLength())]
-        else:
+        elif j >= 0 and j < self.DLength():
             return self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + j * 8))
+        else:
+            return None
+
     # NestedStruct
     def DAsNumpy(self):
         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int64Flags, self._tab.Pos + 16, self.DLength())