From 5fc87f4c4bf04228039c752003931d58a33e7a1b Mon Sep 17 00:00:00 2001
From: lu-wang-g <47436172+lu-wang-g@users.noreply.github.com>
Date: Thu, 9 Dec 2021 15:47:09 -0800
Subject: [PATCH] Enable --gen-onefile in Python (#6953)

* Enable --gen-onefile in Python

Made it possible to generate all python code in one file. Modified
py_test.py so that it can switch between the multi-file code and
the one-file code.

Updated PythonTest.sh and py_test.py so that the multi-file code
and the one-file code can be tested based on the same test code.

* Sync with google/flatbuffers

* Add --gen-onefile to generate_code.py
---
 docs/source/Compiler.md                       |    2 +-
 scripts/generate_code.py                      |    7 +
 src/flatc.cpp                                 |    3 +-
 src/idl_gen_python.cpp                        |  142 +-
 tests/MyGame/Example/Any.py                   |    1 -
 tests/MyGame/Example/AnyAmbiguousAliases.py   |    1 -
 tests/MyGame/Example/AnyUniqueAliases.py      |    1 -
 tests/MyGame/Example/Color.py                 |    1 -
 tests/MyGame/Example/Race.py                  |    1 -
 tests/MyGame/Example/TestEnum.py              |    1 -
 tests/PythonTest.sh                           |   13 +-
 tests/monster_test_generated.py               | 2319 +++++++++
 .../NamespaceA/NamespaceB/EnumInNestedNS.py   |    1 -
 .../NamespaceA/NamespaceB/UnionInNestedNS.py  |    1 -
 tests/py_test.py                              | 4378 +++++++++--------
 15 files changed, 4823 insertions(+), 2049 deletions(-)
 create mode 100644 tests/monster_test_generated.py

diff --git a/docs/source/Compiler.md b/docs/source/Compiler.md
index 249ecdded..386ee07ee 100644
--- a/docs/source/Compiler.md
+++ b/docs/source/Compiler.md
@@ -101,7 +101,7 @@ Additional options:
 -   `--gen-mutable` : Generate additional non-const accessors for mutating
     FlatBuffers in-place.
 
--   `--gen-onefile` : Generate single output file for C# and Go.
+-   `--gen-onefile` : Generate single output file for C#, Go, and Python.
 
 -   `--gen-name-strings` : Generate type name functions for C++.
 
diff --git a/scripts/generate_code.py b/scripts/generate_code.py
index b7bfb5919..7a667d84e 100755
--- a/scripts/generate_code.py
+++ b/scripts/generate_code.py
@@ -162,6 +162,13 @@ flatc(
     data="monsterdata_test.json",
 )
 
+flatc(
+    options=BASE_OPTS + ["--python", "--gen-onefile"],
+    schema="monster_test.fbs",
+    include="include_test",
+    data="monsterdata_test.json",
+)
+
 # For Rust we currently generate two independent schemas, with namespace_test2
 # duplicating the types in namespace_test1
 flatc(
diff --git a/src/flatc.cpp b/src/flatc.cpp
index 15cade49c..fec0584d3 100644
--- a/src/flatc.cpp
+++ b/src/flatc.cpp
@@ -102,7 +102,7 @@ std::string FlatCompiler::GetUsageString(const char *program_name) const {
     "  --no-includes          Don\'t generate include statements for included\n"
     "                         schemas the generated file depends on (C++ / Python).\n"
     "  --gen-mutable          Generate accessors that can mutate buffers in-place.\n"
-    "  --gen-onefile          Generate single output file for C# and Go.\n"
+    "  --gen-onefile          Generate single output file for C#, Go, and Python.\n"
     "  --gen-name-strings     Generate type name functions for C++ and Rust.\n"
     "  --gen-object-api       Generate an additional object-based API.\n"
     "  --gen-compare          Generate operator== for object-based API types.\n"
@@ -331,6 +331,7 @@ int FlatCompiler::Compile(int argc, const char **argv) {
         opts.include_dependence_headers = false;
       } else if (arg == "--gen-onefile") {
         opts.one_file = true;
+        opts.include_dependence_headers = false;
       } else if (arg == "--raw-binary") {
         raw_binary = true;
       } else if (arg == "--size-prefixed") {
diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index 430aefad4..fddeb1a1f 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -113,12 +113,6 @@ class PythonGenerator : public BaseGenerator {
     code += enum_def.ToString(ev) + "\n";
   }
 
-  // End enum code.
-  void EndEnum(std::string *code_ptr) {
-    auto &code = *code_ptr;
-    code += "\n";
-  }
-
   // Initialize a new struct or table from existing data.
   void NewRootTypeFromBuffer(const StructDef &struct_def,
                              std::string *code_ptr) {
@@ -562,10 +556,12 @@ class PythonGenerator : public BaseGenerator {
     code += NumToString(struct_def.fields.vec.size());
     code += ")\n";
 
-    // Generate method without struct name.
-    code += "def Start(builder):\n";
-    code +=
-        Indent + "return " + NormalizedName(struct_def) + "Start(builder)\n";
+    if (!parser_.opts.one_file) {
+      // Generate method without struct name.
+      code += "def Start(builder):\n";
+      code +=
+          Indent + "return " + NormalizedName(struct_def) + "Start(builder)\n";
+    }
   }
 
   // Set the value of a table's field.
@@ -595,16 +591,18 @@ class PythonGenerator : public BaseGenerator {
                 : field.value.constant;
     code += ")\n";
 
-    // Generate method without struct name.
-    code += "def Add" + MakeCamel(NormalizedName(field));
-    code += "(builder, ";
-    code += MakeCamel(NormalizedName(field), false);
-    code += "):\n";
-    code += Indent + "return " + NormalizedName(struct_def) + "Add" +
-            MakeCamel(NormalizedName(field));
-    code += "(builder, ";
-    code += MakeCamel(NormalizedName(field), false);
-    code += ")\n";
+    if (!parser_.opts.one_file) {
+      // Generate method without struct name.
+      code += "def Add" + MakeCamel(NormalizedName(field));
+      code += "(builder, ";
+      code += MakeCamel(NormalizedName(field), false);
+      code += "):\n";
+      code += Indent + "return " + NormalizedName(struct_def) + "Add" +
+              MakeCamel(NormalizedName(field));
+      code += "(builder, ";
+      code += MakeCamel(NormalizedName(field), false);
+      code += ")\n";
+    }
   }
 
   // Set the value of one of the members of a table's vector.
@@ -623,13 +621,15 @@ class PythonGenerator : public BaseGenerator {
     code += ", numElems, " + NumToString(alignment);
     code += ")\n";
 
-    // Generate method without struct name.
-    code += "def Start";
-    code += MakeCamel(NormalizedName(field));
-    code += "Vector(builder, numElems):\n";
-    code += Indent + "return " + NormalizedName(struct_def) + "Start";
-    code += MakeCamel(NormalizedName(field));
-    code += "Vector(builder, numElems)\n";
+    if (!parser_.opts.one_file) {
+      // Generate method without struct name.
+      code += "def Start";
+      code += MakeCamel(NormalizedName(field));
+      code += "Vector(builder, numElems):\n";
+      code += Indent + "return " + NormalizedName(struct_def) + "Start";
+      code += MakeCamel(NormalizedName(field));
+      code += "Vector(builder, numElems)\n";
+    }
   }
 
   // Set the value of one of the members of a table's vector and fills in the
@@ -670,12 +670,14 @@ class PythonGenerator : public BaseGenerator {
     code += " = bytes\n";
     code += Indent + "return builder.EndVector()\n";
 
-    // Generate method without struct and field name.
-    code += "def Make" + MakeCamel(NormalizedName(field)) +
-            "VectorFromBytes(builder, bytes):\n";
-    code += Indent + "return " + NormalizedName(struct_def) + "Make" +
-            MakeCamel(NormalizedName(field)) +
-            "VectorFromBytes(builder, bytes)\n";
+    if (!parser_.opts.one_file) {
+      // Generate method without struct and field name.
+      code += "def Make" + MakeCamel(NormalizedName(field)) +
+              "VectorFromBytes(builder, bytes):\n";
+      code += Indent + "return " + NormalizedName(struct_def) + "Make" +
+              MakeCamel(NormalizedName(field)) +
+              "VectorFromBytes(builder, bytes)\n";
+    }
   }
 
   // Get the offset of the end of a table.
@@ -687,9 +689,11 @@ class PythonGenerator : public BaseGenerator {
     code += "(builder): ";
     code += "return builder.EndObject()\n";
 
-    // Generate method without struct name.
-    code += "def End(builder):\n";
-    code += Indent + "return " + NormalizedName(struct_def) + "End(builder)";
+    if (!parser_.opts.one_file) {
+      // Generate method without struct name.
+      code += "def End(builder):\n";
+      code += Indent + "return " + NormalizedName(struct_def) + "End(builder)";
+    }
   }
 
   // Generate the receiver for function signatures.
@@ -734,8 +738,11 @@ class PythonGenerator : public BaseGenerator {
           }
           break;
         }
-        case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break;
-        default: FLATBUFFERS_ASSERT(0);
+        case BASE_TYPE_UNION:
+          GetUnionField(struct_def, field, code_ptr);
+          break;
+        default:
+          FLATBUFFERS_ASSERT(0);
       }
     }
     if (IsVector(field.value.type) || IsArray(field.value.type)) {
@@ -906,9 +913,14 @@ class PythonGenerator : public BaseGenerator {
             import_list->insert("import " + package_reference);
           }
           break;
-        case BASE_TYPE_STRING: field_type += "str"; break;
-        case BASE_TYPE_NONE: field_type += "None"; break;
-        default: break;
+        case BASE_TYPE_STRING:
+          field_type += "str";
+          break;
+        case BASE_TYPE_NONE:
+          field_type += "None";
+          break;
+        default:
+          break;
       }
       field_types += field_type + separator_string;
     }
@@ -1241,7 +1253,8 @@ class PythonGenerator : public BaseGenerator {
           GenUnPackForScalarVector(struct_def, field, &code);
           break;
         }
-        default: GenUnPackForScalar(struct_def, field, &code);
+        default:
+          GenUnPackForScalar(struct_def, field, &code);
       }
     }
 
@@ -1639,7 +1652,6 @@ class PythonGenerator : public BaseGenerator {
       GenComment(ev.doc_comment, code_ptr, &def_comment, Indent.c_str());
       EnumMember(enum_def, ev, code_ptr);
     }
-    EndEnum(code_ptr);
   }
 
   // Returns the function name that is able to read a value of the given type.
@@ -1709,13 +1721,20 @@ class PythonGenerator : public BaseGenerator {
   }
 
   bool generate() {
-    if (!generateEnums()) return false;
-    if (!generateStructs()) return false;
+    std::string one_file_code;
+    if (!generateEnums(&one_file_code)) return false;
+    if (!generateStructs(&one_file_code)) return false;
+
+    if (parser_.opts.one_file) {
+      return SaveType(file_name_ + "_generated", *parser_.current_namespace_,
+                      one_file_code, true);
+    }
+
     return true;
   }
 
  private:
-  bool generateEnums() {
+  bool generateEnums(std::string *one_file_code) {
     for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
          ++it) {
       auto &enum_def = **it;
@@ -1724,12 +1743,19 @@ class PythonGenerator : public BaseGenerator {
       if (parser_.opts.generate_object_based_api & enum_def.is_union) {
         GenUnionCreator(enum_def, &enumcode);
       }
-      if (!SaveType(enum_def, enumcode, false)) return false;
+
+      if (parser_.opts.one_file && !enumcode.empty()) {
+        *one_file_code += enumcode + "\n\n";
+      } else {
+        if (!SaveType(enum_def.name, *enum_def.defined_namespace, enumcode,
+                      false))
+          return false;
+      }
     }
     return true;
   }
 
-  bool generateStructs() {
+  bool generateStructs(std::string *one_file_code) {
     for (auto it = parser_.structs_.vec.begin();
          it != parser_.structs_.vec.end(); ++it) {
       auto &struct_def = **it;
@@ -1738,7 +1764,14 @@ class PythonGenerator : public BaseGenerator {
       if (parser_.opts.generate_object_based_api) {
         GenStructForObjectAPI(struct_def, &declcode);
       }
-      if (!SaveType(struct_def, declcode, true)) return false;
+
+      if (parser_.opts.one_file && !declcode.empty()) {
+        *one_file_code += declcode + "\n\n";
+      } else {
+        if (!SaveType(struct_def.name, *struct_def.defined_namespace, declcode,
+                      true))
+          return false;
+      }
     }
     return true;
   }
@@ -1757,12 +1790,12 @@ class PythonGenerator : public BaseGenerator {
   }
 
   // Save out the generated code for a Python Table type.
-  bool SaveType(const Definition &def, const std::string &classcode,
-                bool needs_imports) {
+  bool SaveType(const std::string &defname, const Namespace &ns,
+                const std::string &classcode, bool needs_imports) {
     if (!classcode.length()) return true;
 
     std::string namespace_dir = path_;
-    auto &namespaces = def.defined_namespace->components;
+    auto &namespaces = ns.components;
     for (auto it = namespaces.begin(); it != namespaces.end(); ++it) {
       if (it != namespaces.begin()) namespace_dir += kPathSeparator;
       namespace_dir += *it;
@@ -1771,10 +1804,9 @@ class PythonGenerator : public BaseGenerator {
     }
 
     std::string code = "";
-    BeginFile(LastNamespacePart(*def.defined_namespace), needs_imports, &code);
+    BeginFile(LastNamespacePart(ns), needs_imports, &code);
     code += classcode;
-    std::string filename =
-        NamespaceDir(*def.defined_namespace) + NormalizedName(def) + ".py";
+    std::string filename = NamespaceDir(ns) + defname + ".py";
     return SaveFile(filename.c_str(), code, false);
   }
 
diff --git a/tests/MyGame/Example/Any.py b/tests/MyGame/Example/Any.py
index b10d35df4..998368952 100644
--- a/tests/MyGame/Example/Any.py
+++ b/tests/MyGame/Example/Any.py
@@ -8,7 +8,6 @@ class Any(object):
     TestSimpleTableWithEnum = 2
     MyGame_Example2_Monster = 3
 
-
 def AnyCreator(unionType, table):
     from flatbuffers.table import Table
     if not isinstance(table, Table):
diff --git a/tests/MyGame/Example/AnyAmbiguousAliases.py b/tests/MyGame/Example/AnyAmbiguousAliases.py
index 3fb4830fb..2225a036c 100644
--- a/tests/MyGame/Example/AnyAmbiguousAliases.py
+++ b/tests/MyGame/Example/AnyAmbiguousAliases.py
@@ -8,7 +8,6 @@ class AnyAmbiguousAliases(object):
     M2 = 2
     M3 = 3
 
-
 def AnyAmbiguousAliasesCreator(unionType, table):
     from flatbuffers.table import Table
     if not isinstance(table, Table):
diff --git a/tests/MyGame/Example/AnyUniqueAliases.py b/tests/MyGame/Example/AnyUniqueAliases.py
index cf89fc290..a3ba37e7f 100644
--- a/tests/MyGame/Example/AnyUniqueAliases.py
+++ b/tests/MyGame/Example/AnyUniqueAliases.py
@@ -8,7 +8,6 @@ class AnyUniqueAliases(object):
     TS = 2
     M2 = 3
 
-
 def AnyUniqueAliasesCreator(unionType, table):
     from flatbuffers.table import Table
     if not isinstance(table, Table):
diff --git a/tests/MyGame/Example/Color.py b/tests/MyGame/Example/Color.py
index 55aa82126..4ab9cc9b8 100644
--- a/tests/MyGame/Example/Color.py
+++ b/tests/MyGame/Example/Color.py
@@ -10,4 +10,3 @@ class Color(object):
     Green = 2
     # \brief color Blue (1u << 3)
     Blue = 8
-
diff --git a/tests/MyGame/Example/Race.py b/tests/MyGame/Example/Race.py
index a39c6ead6..30f39601e 100644
--- a/tests/MyGame/Example/Race.py
+++ b/tests/MyGame/Example/Race.py
@@ -7,4 +7,3 @@ class Race(object):
     Human = 0
     Dwarf = 1
     Elf = 2
-
diff --git a/tests/MyGame/Example/TestEnum.py b/tests/MyGame/Example/TestEnum.py
index d49f10a15..4f5f60800 100644
--- a/tests/MyGame/Example/TestEnum.py
+++ b/tests/MyGame/Example/TestEnum.py
@@ -6,4 +6,3 @@ class TestEnum(object):
     A = 0
     B = 1
     C = 2
-
diff --git a/tests/PythonTest.sh b/tests/PythonTest.sh
index b387ec1b2..00772eae3 100755
--- a/tests/PythonTest.sh
+++ b/tests/PythonTest.sh
@@ -21,6 +21,7 @@ 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
 
 # Syntax: run_tests <interpreter> <benchmark vtable dedupes>
@@ -35,7 +36,7 @@ function run_tests() {
     JYTHONPATH=${runtime_library_dir}:${gen_code_path} \
     COMPARE_GENERATED_TO_GO=0 \
     COMPARE_GENERATED_TO_JAVA=0 \
-    $1 py_test.py $2 $3 $4
+    $1 py_test.py $2 $3 $4 $5
     if [ $1 = python3 ]; then
       PYTHONDONTWRITEBYTECODE=1 \
       PYTHONPATH=${runtime_library_dir}:${gen_code_path} \
@@ -47,10 +48,12 @@ function run_tests() {
 }
 
 # Run test suite with these interpreters. The arguments are benchmark counts.
-run_tests python2.6 100 100 100
-run_tests python2.7 100 100 100
-run_tests python3 100 100 100
-run_tests pypy 100 100 100
+run_tests python2.6 100 100 100 false
+run_tests python2.7 100 100 100 false
+run_tests python2.7 100 100 100 true
+run_tests python3 100 100 100 false
+run_tests python3 100 100 100 true
+run_tests pypy 100 100 100 false
 
 # NOTE: We'd like to support python2.5 in the future.
 
diff --git a/tests/monster_test_generated.py b/tests/monster_test_generated.py
new file mode 100644
index 000000000..2c2e4a87e
--- /dev/null
+++ b/tests/monster_test_generated.py
@@ -0,0 +1,2319 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: Example
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Composite components of Monster color.
+class Color(object):
+    Red = 1
+    # \brief color Green
+    # Green is bit_flag with value (1u << 1)
+    Green = 2
+    # \brief color Blue (1u << 3)
+    Blue = 8
+
+
+class Race(object):
+    None_ = -1
+    Human = 0
+    Dwarf = 1
+    Elf = 2
+
+
+class Any(object):
+    NONE = 0
+    Monster = 1
+    TestSimpleTableWithEnum = 2
+    MyGame_Example2_Monster = 3
+
+def AnyCreator(unionType, table):
+    from flatbuffers.table import Table
+    if not isinstance(table, Table):
+        return None
+    if unionType == Any().Monster:
+        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == Any().TestSimpleTableWithEnum:
+        return TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == Any().MyGame_Example2_Monster:
+        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
+    return None
+
+
+class AnyUniqueAliases(object):
+    NONE = 0
+    M = 1
+    TS = 2
+    M2 = 3
+
+def AnyUniqueAliasesCreator(unionType, table):
+    from flatbuffers.table import Table
+    if not isinstance(table, Table):
+        return None
+    if unionType == AnyUniqueAliases().M:
+        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == AnyUniqueAliases().TS:
+        return TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == AnyUniqueAliases().M2:
+        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
+    return None
+
+
+class AnyAmbiguousAliases(object):
+    NONE = 0
+    M1 = 1
+    M2 = 2
+    M3 = 3
+
+def AnyAmbiguousAliasesCreator(unionType, table):
+    from flatbuffers.table import Table
+    if not isinstance(table, Table):
+        return None
+    if unionType == AnyAmbiguousAliases().M1:
+        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == AnyAmbiguousAliases().M2:
+        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
+    if unionType == AnyAmbiguousAliases().M3:
+        return MonsterT.InitFromBuf(table.Bytes, table.Pos)
+    return None
+
+
+class InParentNamespace(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = InParentNamespace()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsInParentNamespace(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def InParentNamespaceBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
+
+    # InParentNamespace
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def InParentNamespaceStart(builder): builder.StartObject(0)
+def InParentNamespaceEnd(builder): return builder.EndObject()
+
+
+class InParentNamespaceT(object):
+
+    # InParentNamespaceT
+    def __init__(self):
+        pass
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        inParentNamespace = InParentNamespace()
+        inParentNamespace.Init(buf, pos)
+        return cls.InitFromObj(inParentNamespace)
+
+    @classmethod
+    def InitFromObj(cls, inParentNamespace):
+        x = InParentNamespaceT()
+        x._UnPack(inParentNamespace)
+        return x
+
+    # InParentNamespaceT
+    def _UnPack(self, inParentNamespace):
+        if inParentNamespace is None:
+            return
+
+    # InParentNamespaceT
+    def Pack(self, builder):
+        InParentNamespaceStart(builder)
+        inParentNamespace = InParentNamespaceEnd(builder)
+        return inParentNamespace
+
+
+class Monster(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Monster()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMonster(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
+
+    # Monster
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def MonsterStart(builder): builder.StartObject(0)
+def MonsterEnd(builder): return builder.EndObject()
+
+
+class MonsterT(object):
+
+    # MonsterT
+    def __init__(self):
+        pass
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        monster = Monster()
+        monster.Init(buf, pos)
+        return cls.InitFromObj(monster)
+
+    @classmethod
+    def InitFromObj(cls, monster):
+        x = MonsterT()
+        x._UnPack(monster)
+        return x
+
+    # MonsterT
+    def _UnPack(self, monster):
+        if monster is None:
+            return
+
+    # MonsterT
+    def Pack(self, builder):
+        MonsterStart(builder)
+        monster = MonsterEnd(builder)
+        return monster
+
+
+class Test(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def SizeOf(cls):
+        return 4
+
+    # Test
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Test
+    def A(self): return self._tab.Get(flatbuffers.number_types.Int16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
+    # Test
+    def B(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2))
+
+def CreateTest(builder, a, b):
+    builder.Prep(2, 4)
+    builder.Pad(1)
+    builder.PrependInt8(b)
+    builder.PrependInt16(a)
+    return builder.Offset()
+
+
+class TestT(object):
+
+    # TestT
+    def __init__(self):
+        self.a = 0  # type: int
+        self.b = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        test = Test()
+        test.Init(buf, pos)
+        return cls.InitFromObj(test)
+
+    @classmethod
+    def InitFromObj(cls, test):
+        x = TestT()
+        x._UnPack(test)
+        return x
+
+    # TestT
+    def _UnPack(self, test):
+        if test is None:
+            return
+        self.a = test.A()
+        self.b = test.B()
+
+    # TestT
+    def Pack(self, builder):
+        return CreateTest(builder, self.a, self.b)
+
+
+class TestSimpleTableWithEnum(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = TestSimpleTableWithEnum()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsTestSimpleTableWithEnum(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def TestSimpleTableWithEnumBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
+
+    # TestSimpleTableWithEnum
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # TestSimpleTableWithEnum
+    def Color(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 2
+
+def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
+def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
+def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
+
+
+class TestSimpleTableWithEnumT(object):
+
+    # TestSimpleTableWithEnumT
+    def __init__(self):
+        self.color = 2  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        testSimpleTableWithEnum = TestSimpleTableWithEnum()
+        testSimpleTableWithEnum.Init(buf, pos)
+        return cls.InitFromObj(testSimpleTableWithEnum)
+
+    @classmethod
+    def InitFromObj(cls, testSimpleTableWithEnum):
+        x = TestSimpleTableWithEnumT()
+        x._UnPack(testSimpleTableWithEnum)
+        return x
+
+    # TestSimpleTableWithEnumT
+    def _UnPack(self, testSimpleTableWithEnum):
+        if testSimpleTableWithEnum is None:
+            return
+        self.color = testSimpleTableWithEnum.Color()
+
+    # TestSimpleTableWithEnumT
+    def Pack(self, builder):
+        TestSimpleTableWithEnumStart(builder)
+        TestSimpleTableWithEnumAddColor(builder, self.color)
+        testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
+        return testSimpleTableWithEnum
+
+
+class Vec3(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def SizeOf(cls):
+        return 32
+
+    # Vec3
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Vec3
+    def X(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
+    # Vec3
+    def Y(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4))
+    # Vec3
+    def Z(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8))
+    # Vec3
+    def Test1(self): return self._tab.Get(flatbuffers.number_types.Float64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16))
+    # Vec3
+    def Test2(self): return self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(24))
+    # Vec3
+    def Test3(self, obj):
+        obj.Init(self._tab.Bytes, self._tab.Pos + 26)
+        return obj
+
+
+def CreateVec3(builder, x, y, z, test1, test2, test3_a, test3_b):
+    builder.Prep(8, 32)
+    builder.Pad(2)
+    builder.Prep(2, 4)
+    builder.Pad(1)
+    builder.PrependInt8(test3_b)
+    builder.PrependInt16(test3_a)
+    builder.Pad(1)
+    builder.PrependUint8(test2)
+    builder.PrependFloat64(test1)
+    builder.Pad(4)
+    builder.PrependFloat32(z)
+    builder.PrependFloat32(y)
+    builder.PrependFloat32(x)
+    return builder.Offset()
+
+try:
+    from typing import Optional
+except:
+    pass
+
+class Vec3T(object):
+
+    # Vec3T
+    def __init__(self):
+        self.x = 0.0  # type: float
+        self.y = 0.0  # type: float
+        self.z = 0.0  # type: float
+        self.test1 = 0.0  # type: float
+        self.test2 = 0  # type: int
+        self.test3 = None  # type: Optional[TestT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        vec3 = Vec3()
+        vec3.Init(buf, pos)
+        return cls.InitFromObj(vec3)
+
+    @classmethod
+    def InitFromObj(cls, vec3):
+        x = Vec3T()
+        x._UnPack(vec3)
+        return x
+
+    # Vec3T
+    def _UnPack(self, vec3):
+        if vec3 is None:
+            return
+        self.x = vec3.X()
+        self.y = vec3.Y()
+        self.z = vec3.Z()
+        self.test1 = vec3.Test1()
+        self.test2 = vec3.Test2()
+        if vec3.Test3(Test()) is not None:
+            self.test3 = TestT.InitFromObj(vec3.Test3(Test()))
+
+    # Vec3T
+    def Pack(self, builder):
+        return CreateVec3(builder, self.x, self.y, self.z, self.test1, self.test2, self.test3.a, self.test3.b)
+
+
+class Ability(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def SizeOf(cls):
+        return 8
+
+    # Ability
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Ability
+    def Id(self): return self._tab.Get(flatbuffers.number_types.Uint32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
+    # Ability
+    def Distance(self): return self._tab.Get(flatbuffers.number_types.Uint32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4))
+
+def CreateAbility(builder, id, distance):
+    builder.Prep(4, 8)
+    builder.PrependUint32(distance)
+    builder.PrependUint32(id)
+    return builder.Offset()
+
+
+class AbilityT(object):
+
+    # AbilityT
+    def __init__(self):
+        self.id = 0  # type: int
+        self.distance = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        ability = Ability()
+        ability.Init(buf, pos)
+        return cls.InitFromObj(ability)
+
+    @classmethod
+    def InitFromObj(cls, ability):
+        x = AbilityT()
+        x._UnPack(ability)
+        return x
+
+    # AbilityT
+    def _UnPack(self, ability):
+        if ability is None:
+            return
+        self.id = ability.Id()
+        self.distance = ability.Distance()
+
+    # AbilityT
+    def Pack(self, builder):
+        return CreateAbility(builder, self.id, self.distance)
+
+
+class StructOfStructs(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def SizeOf(cls):
+        return 20
+
+    # StructOfStructs
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # StructOfStructs
+    def A(self, obj):
+        obj.Init(self._tab.Bytes, self._tab.Pos + 0)
+        return obj
+
+    # StructOfStructs
+    def B(self, obj):
+        obj.Init(self._tab.Bytes, self._tab.Pos + 8)
+        return obj
+
+    # StructOfStructs
+    def C(self, obj):
+        obj.Init(self._tab.Bytes, self._tab.Pos + 12)
+        return obj
+
+
+def CreateStructOfStructs(builder, a_id, a_distance, b_a, b_b, c_id, c_distance):
+    builder.Prep(4, 20)
+    builder.Prep(4, 8)
+    builder.PrependUint32(c_distance)
+    builder.PrependUint32(c_id)
+    builder.Prep(2, 4)
+    builder.Pad(1)
+    builder.PrependInt8(b_b)
+    builder.PrependInt16(b_a)
+    builder.Prep(4, 8)
+    builder.PrependUint32(a_distance)
+    builder.PrependUint32(a_id)
+    return builder.Offset()
+
+try:
+    from typing import Optional
+except:
+    pass
+
+class StructOfStructsT(object):
+
+    # StructOfStructsT
+    def __init__(self):
+        self.a = None  # type: Optional[AbilityT]
+        self.b = None  # type: Optional[TestT]
+        self.c = None  # type: Optional[AbilityT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        structOfStructs = StructOfStructs()
+        structOfStructs.Init(buf, pos)
+        return cls.InitFromObj(structOfStructs)
+
+    @classmethod
+    def InitFromObj(cls, structOfStructs):
+        x = StructOfStructsT()
+        x._UnPack(structOfStructs)
+        return x
+
+    # StructOfStructsT
+    def _UnPack(self, structOfStructs):
+        if structOfStructs is None:
+            return
+        if structOfStructs.A(Ability()) is not None:
+            self.a = AbilityT.InitFromObj(structOfStructs.A(Ability()))
+        if structOfStructs.B(Test()) is not None:
+            self.b = TestT.InitFromObj(structOfStructs.B(Test()))
+        if structOfStructs.C(Ability()) is not None:
+            self.c = AbilityT.InitFromObj(structOfStructs.C(Ability()))
+
+    # StructOfStructsT
+    def Pack(self, builder):
+        return CreateStructOfStructs(builder, self.a.id, self.a.distance, self.b.a, self.b.b, self.c.id, self.c.distance)
+
+
+class Stat(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Stat()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStat(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StatBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
+
+    # Stat
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Stat
+    def Id(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Stat
+    def Val(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # Stat
+    def Count(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+def StatStart(builder): builder.StartObject(3)
+def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
+def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
+def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
+def StatEnd(builder): return builder.EndObject()
+
+
+class StatT(object):
+
+    # StatT
+    def __init__(self):
+        self.id = None  # type: str
+        self.val = 0  # type: int
+        self.count = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stat = Stat()
+        stat.Init(buf, pos)
+        return cls.InitFromObj(stat)
+
+    @classmethod
+    def InitFromObj(cls, stat):
+        x = StatT()
+        x._UnPack(stat)
+        return x
+
+    # StatT
+    def _UnPack(self, stat):
+        if stat is None:
+            return
+        self.id = stat.Id()
+        self.val = stat.Val()
+        self.count = stat.Count()
+
+    # StatT
+    def Pack(self, builder):
+        if self.id is not None:
+            id = builder.CreateString(self.id)
+        StatStart(builder)
+        if self.id is not None:
+            StatAddId(builder, id)
+        StatAddVal(builder, self.val)
+        StatAddCount(builder, self.count)
+        stat = StatEnd(builder)
+        return stat
+
+
+class Referrable(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Referrable()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsReferrable(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ReferrableBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
+
+    # Referrable
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Referrable
+    def Id(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def ReferrableStart(builder): builder.StartObject(1)
+def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
+def ReferrableEnd(builder): return builder.EndObject()
+
+
+class ReferrableT(object):
+
+    # ReferrableT
+    def __init__(self):
+        self.id = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        referrable = Referrable()
+        referrable.Init(buf, pos)
+        return cls.InitFromObj(referrable)
+
+    @classmethod
+    def InitFromObj(cls, referrable):
+        x = ReferrableT()
+        x._UnPack(referrable)
+        return x
+
+    # ReferrableT
+    def _UnPack(self, referrable):
+        if referrable is None:
+            return
+        self.id = referrable.Id()
+
+    # ReferrableT
+    def Pack(self, builder):
+        ReferrableStart(builder)
+        ReferrableAddId(builder, self.id)
+        referrable = ReferrableEnd(builder)
+        return referrable
+
+
+# an example documentation comment: "monster object"
+class Monster(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Monster()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMonster(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
+
+    # Monster
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Monster
+    def Pos(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = o + self._tab.Pos
+            obj = Vec3()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    def Mana(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
+        return 150
+
+    # Monster
+    def Hp(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
+        return 100
+
+    # Monster
+    def Name(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Monster
+    def Inventory(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Monster
+    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
+    def InventoryIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Monster
+    def Color(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 8
+
+    # Monster
+    def TestType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Test(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # Monster
+    def Test4(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            obj = Test()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    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
+    def Test4IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        return o == 0
+
+    # Monster
+    def Testarrayofstring(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Monster
+    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
+    def TestarrayofstringIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+    # an example documentation comment: this will end up in the generated code
+    # multiline too
+    # Monster
+    def Testarrayoftables(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            obj = Monster()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    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
+    def TestarrayoftablesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
+
+    # Monster
+    def Enemy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            obj = Monster()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    def Testnestedflatbuffer(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Monster
+    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
+    def TestnestedflatbufferNestedRoot(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            from MyGame.Example.Monster import Monster
+            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
+        return 0
+
+    # Monster
+    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
+    def TestnestedflatbufferIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
+
+    # Monster
+    def Testempty(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            obj = Stat()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    def Testbool(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Monster
+    def Testhashs32Fnv1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Testhashu32Fnv1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Testhashs64Fnv1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Testhashu64Fnv1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Testhashs32Fnv1a(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Testhashu32Fnv1a(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Testhashs64Fnv1a(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Testhashu64Fnv1a(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def Testarrayofbools(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Monster
+    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
+    def TestarrayofboolsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+        return o == 0
+
+    # Monster
+    def Testf(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 3.14159
+
+    # Monster
+    def Testf2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 3.0
+
+    # Monster
+    def Testf3(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Monster
+    def Testarrayofstring2(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Monster
+    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
+    def Testarrayofstring2IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+        return o == 0
+
+    # Monster
+    def Testarrayofsortedstruct(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            obj = Ability()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    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
+    def TestarrayofsortedstructIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+        return o == 0
+
+    # Monster
+    def Flex(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Monster
+    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
+    def FlexIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+        return o == 0
+
+    # Monster
+    def Test5(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            obj = Test()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    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
+    def Test5IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+        return o == 0
+
+    # Monster
+    def VectorOfLongs(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Monster
+    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
+    def VectorOfLongsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
+        return o == 0
+
+    # Monster
+    def VectorOfDoubles(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Monster
+    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
+    def VectorOfDoublesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
+        return o == 0
+
+    # Monster
+    def ParentNamespaceTest(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            obj = InParentNamespace()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    def VectorOfReferrables(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            obj = Referrable()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    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
+    def VectorOfReferrablesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
+        return o == 0
+
+    # Monster
+    def SingleWeakReference(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def VectorOfWeakReferences(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Monster
+    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
+    def VectorOfWeakReferencesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
+        return o == 0
+
+    # Monster
+    def VectorOfStrongReferrables(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            obj = Referrable()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    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
+    def VectorOfStrongReferrablesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+        return o == 0
+
+    # Monster
+    def CoOwningReference(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def VectorOfCoOwningReferences(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Monster
+    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
+    def VectorOfCoOwningReferencesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
+        return o == 0
+
+    # Monster
+    def NonOwningReference(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def VectorOfNonOwningReferences(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Monster
+    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
+    def VectorOfNonOwningReferencesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
+        return o == 0
+
+    # Monster
+    def AnyUniqueType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def AnyUnique(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # Monster
+    def AnyAmbiguousType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Monster
+    def AnyAmbiguous(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # Monster
+    def VectorOfEnums(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Monster
+    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
+    def VectorOfEnumsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
+        return o == 0
+
+    # Monster
+    def SignedEnum(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return -1
+
+    # Monster
+    def Testrequirednestedflatbuffer(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Monster
+    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
+    def TestrequirednestedflatbufferNestedRoot(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+        if o != 0:
+            from MyGame.Example.Monster import Monster
+            return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
+        return 0
+
+    # Monster
+    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
+    def TestrequirednestedflatbufferIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+        return o == 0
+
+    # Monster
+    def ScalarKeySortedTables(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            obj = Stat()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Monster
+    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
+    def ScalarKeySortedTablesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
+        return o == 0
+
+def MonsterStart(builder): builder.StartObject(51)
+def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
+def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
+def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
+def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
+def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
+def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
+def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
+def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
+def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
+def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
+def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
+def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
+def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
+def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
+    builder.StartVector(1, len(bytes), 1)
+    builder.head = builder.head - len(bytes)
+    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
+    return builder.EndVector()
+def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
+def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
+def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
+def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
+def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
+def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
+def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
+def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
+def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
+def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
+def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
+def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
+def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
+def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
+def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
+def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
+def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
+def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
+def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
+def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
+def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
+def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
+def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
+def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
+def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
+def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
+def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
+def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
+def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
+def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
+def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
+def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
+def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
+def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
+def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
+def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
+    builder.StartVector(1, len(bytes), 1)
+    builder.head = builder.head - len(bytes)
+    builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
+    return builder.EndVector()
+def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
+def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterEnd(builder): return builder.EndObject()
+
+try:
+    from typing import List, Optional, Union
+except:
+    pass
+
+class MonsterT(object):
+
+    # MonsterT
+    def __init__(self):
+        self.pos = None  # type: Optional[Vec3T]
+        self.mana = 150  # type: int
+        self.hp = 100  # type: int
+        self.name = None  # type: str
+        self.inventory = None  # type: List[int]
+        self.color = 8  # type: int
+        self.testType = 0  # type: int
+        self.test = None  # type: Union[None, MonsterT, TestSimpleTableWithEnumT, MonsterT]
+        self.test4 = None  # type: List[TestT]
+        self.testarrayofstring = None  # type: List[str]
+        self.testarrayoftables = None  # type: List[MonsterT]
+        self.enemy = None  # type: Optional[MonsterT]
+        self.testnestedflatbuffer = None  # type: List[int]
+        self.testempty = None  # type: Optional[StatT]
+        self.testbool = False  # type: bool
+        self.testhashs32Fnv1 = 0  # type: int
+        self.testhashu32Fnv1 = 0  # type: int
+        self.testhashs64Fnv1 = 0  # type: int
+        self.testhashu64Fnv1 = 0  # type: int
+        self.testhashs32Fnv1a = 0  # type: int
+        self.testhashu32Fnv1a = 0  # type: int
+        self.testhashs64Fnv1a = 0  # type: int
+        self.testhashu64Fnv1a = 0  # type: int
+        self.testarrayofbools = None  # type: List[bool]
+        self.testf = 3.14159  # type: float
+        self.testf2 = 3.0  # type: float
+        self.testf3 = 0.0  # type: float
+        self.testarrayofstring2 = None  # type: List[str]
+        self.testarrayofsortedstruct = None  # type: List[AbilityT]
+        self.flex = None  # type: List[int]
+        self.test5 = None  # type: List[TestT]
+        self.vectorOfLongs = None  # type: List[int]
+        self.vectorOfDoubles = None  # type: List[float]
+        self.parentNamespaceTest = None  # type: Optional[InParentNamespaceT]
+        self.vectorOfReferrables = None  # type: List[ReferrableT]
+        self.singleWeakReference = 0  # type: int
+        self.vectorOfWeakReferences = None  # type: List[int]
+        self.vectorOfStrongReferrables = None  # type: List[ReferrableT]
+        self.coOwningReference = 0  # type: int
+        self.vectorOfCoOwningReferences = None  # type: List[int]
+        self.nonOwningReference = 0  # type: int
+        self.vectorOfNonOwningReferences = None  # type: List[int]
+        self.anyUniqueType = 0  # type: int
+        self.anyUnique = None  # type: Union[None, MonsterT, TestSimpleTableWithEnumT, MonsterT]
+        self.anyAmbiguousType = 0  # type: int
+        self.anyAmbiguous = None  # type: Union[None, MonsterT, MonsterT, MonsterT]
+        self.vectorOfEnums = None  # type: List[int]
+        self.signedEnum = -1  # type: int
+        self.testrequirednestedflatbuffer = None  # type: List[int]
+        self.scalarKeySortedTables = None  # type: List[StatT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        monster = Monster()
+        monster.Init(buf, pos)
+        return cls.InitFromObj(monster)
+
+    @classmethod
+    def InitFromObj(cls, monster):
+        x = MonsterT()
+        x._UnPack(monster)
+        return x
+
+    # MonsterT
+    def _UnPack(self, monster):
+        if monster is None:
+            return
+        if monster.Pos() is not None:
+            self.pos = Vec3T.InitFromObj(monster.Pos())
+        self.mana = monster.Mana()
+        self.hp = monster.Hp()
+        self.name = monster.Name()
+        if not monster.InventoryIsNone():
+            if np is None:
+                self.inventory = []
+                for i in range(monster.InventoryLength()):
+                    self.inventory.append(monster.Inventory(i))
+            else:
+                self.inventory = monster.InventoryAsNumpy()
+        self.color = monster.Color()
+        self.testType = monster.TestType()
+        self.test = AnyCreator(self.testType, monster.Test())
+        if not monster.Test4IsNone():
+            self.test4 = []
+            for i in range(monster.Test4Length()):
+                if monster.Test4(i) is None:
+                    self.test4.append(None)
+                else:
+                    test_ = TestT.InitFromObj(monster.Test4(i))
+                    self.test4.append(test_)
+        if not monster.TestarrayofstringIsNone():
+            self.testarrayofstring = []
+            for i in range(monster.TestarrayofstringLength()):
+                self.testarrayofstring.append(monster.Testarrayofstring(i))
+        if not monster.TestarrayoftablesIsNone():
+            self.testarrayoftables = []
+            for i in range(monster.TestarrayoftablesLength()):
+                if monster.Testarrayoftables(i) is None:
+                    self.testarrayoftables.append(None)
+                else:
+                    monster_ = MonsterT.InitFromObj(monster.Testarrayoftables(i))
+                    self.testarrayoftables.append(monster_)
+        if monster.Enemy() is not None:
+            self.enemy = MonsterT.InitFromObj(monster.Enemy())
+        if not monster.TestnestedflatbufferIsNone():
+            if np is None:
+                self.testnestedflatbuffer = []
+                for i in range(monster.TestnestedflatbufferLength()):
+                    self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
+            else:
+                self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
+        if monster.Testempty() is not None:
+            self.testempty = StatT.InitFromObj(monster.Testempty())
+        self.testbool = monster.Testbool()
+        self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
+        self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
+        self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
+        self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
+        self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
+        self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
+        self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
+        self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
+        if not monster.TestarrayofboolsIsNone():
+            if np is None:
+                self.testarrayofbools = []
+                for i in range(monster.TestarrayofboolsLength()):
+                    self.testarrayofbools.append(monster.Testarrayofbools(i))
+            else:
+                self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
+        self.testf = monster.Testf()
+        self.testf2 = monster.Testf2()
+        self.testf3 = monster.Testf3()
+        if not monster.Testarrayofstring2IsNone():
+            self.testarrayofstring2 = []
+            for i in range(monster.Testarrayofstring2Length()):
+                self.testarrayofstring2.append(monster.Testarrayofstring2(i))
+        if not monster.TestarrayofsortedstructIsNone():
+            self.testarrayofsortedstruct = []
+            for i in range(monster.TestarrayofsortedstructLength()):
+                if monster.Testarrayofsortedstruct(i) is None:
+                    self.testarrayofsortedstruct.append(None)
+                else:
+                    ability_ = AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
+                    self.testarrayofsortedstruct.append(ability_)
+        if not monster.FlexIsNone():
+            if np is None:
+                self.flex = []
+                for i in range(monster.FlexLength()):
+                    self.flex.append(monster.Flex(i))
+            else:
+                self.flex = monster.FlexAsNumpy()
+        if not monster.Test5IsNone():
+            self.test5 = []
+            for i in range(monster.Test5Length()):
+                if monster.Test5(i) is None:
+                    self.test5.append(None)
+                else:
+                    test_ = TestT.InitFromObj(monster.Test5(i))
+                    self.test5.append(test_)
+        if not monster.VectorOfLongsIsNone():
+            if np is None:
+                self.vectorOfLongs = []
+                for i in range(monster.VectorOfLongsLength()):
+                    self.vectorOfLongs.append(monster.VectorOfLongs(i))
+            else:
+                self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
+        if not monster.VectorOfDoublesIsNone():
+            if np is None:
+                self.vectorOfDoubles = []
+                for i in range(monster.VectorOfDoublesLength()):
+                    self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
+            else:
+                self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
+        if monster.ParentNamespaceTest() is not None:
+            self.parentNamespaceTest = InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
+        if not monster.VectorOfReferrablesIsNone():
+            self.vectorOfReferrables = []
+            for i in range(monster.VectorOfReferrablesLength()):
+                if monster.VectorOfReferrables(i) is None:
+                    self.vectorOfReferrables.append(None)
+                else:
+                    referrable_ = ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
+                    self.vectorOfReferrables.append(referrable_)
+        self.singleWeakReference = monster.SingleWeakReference()
+        if not monster.VectorOfWeakReferencesIsNone():
+            if np is None:
+                self.vectorOfWeakReferences = []
+                for i in range(monster.VectorOfWeakReferencesLength()):
+                    self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
+            else:
+                self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
+        if not monster.VectorOfStrongReferrablesIsNone():
+            self.vectorOfStrongReferrables = []
+            for i in range(monster.VectorOfStrongReferrablesLength()):
+                if monster.VectorOfStrongReferrables(i) is None:
+                    self.vectorOfStrongReferrables.append(None)
+                else:
+                    referrable_ = ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
+                    self.vectorOfStrongReferrables.append(referrable_)
+        self.coOwningReference = monster.CoOwningReference()
+        if not monster.VectorOfCoOwningReferencesIsNone():
+            if np is None:
+                self.vectorOfCoOwningReferences = []
+                for i in range(monster.VectorOfCoOwningReferencesLength()):
+                    self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
+            else:
+                self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
+        self.nonOwningReference = monster.NonOwningReference()
+        if not monster.VectorOfNonOwningReferencesIsNone():
+            if np is None:
+                self.vectorOfNonOwningReferences = []
+                for i in range(monster.VectorOfNonOwningReferencesLength()):
+                    self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
+            else:
+                self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
+        self.anyUniqueType = monster.AnyUniqueType()
+        self.anyUnique = AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
+        self.anyAmbiguousType = monster.AnyAmbiguousType()
+        self.anyAmbiguous = AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
+        if not monster.VectorOfEnumsIsNone():
+            if np is None:
+                self.vectorOfEnums = []
+                for i in range(monster.VectorOfEnumsLength()):
+                    self.vectorOfEnums.append(monster.VectorOfEnums(i))
+            else:
+                self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
+        self.signedEnum = monster.SignedEnum()
+        if not monster.TestrequirednestedflatbufferIsNone():
+            if np is None:
+                self.testrequirednestedflatbuffer = []
+                for i in range(monster.TestrequirednestedflatbufferLength()):
+                    self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
+            else:
+                self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
+        if not monster.ScalarKeySortedTablesIsNone():
+            self.scalarKeySortedTables = []
+            for i in range(monster.ScalarKeySortedTablesLength()):
+                if monster.ScalarKeySortedTables(i) is None:
+                    self.scalarKeySortedTables.append(None)
+                else:
+                    stat_ = StatT.InitFromObj(monster.ScalarKeySortedTables(i))
+                    self.scalarKeySortedTables.append(stat_)
+
+    # MonsterT
+    def Pack(self, builder):
+        if self.name is not None:
+            name = builder.CreateString(self.name)
+        if self.inventory is not None:
+            if np is not None and type(self.inventory) is np.ndarray:
+                inventory = builder.CreateNumpyVector(self.inventory)
+            else:
+                MonsterStartInventoryVector(builder, len(self.inventory))
+                for i in reversed(range(len(self.inventory))):
+                    builder.PrependUint8(self.inventory[i])
+                inventory = builder.EndVector()
+        if self.test is not None:
+            test = self.test.Pack(builder)
+        if self.test4 is not None:
+            MonsterStartTest4Vector(builder, len(self.test4))
+            for i in reversed(range(len(self.test4))):
+                self.test4[i].Pack(builder)
+            test4 = builder.EndVector()
+        if self.testarrayofstring is not None:
+            testarrayofstringlist = []
+            for i in range(len(self.testarrayofstring)):
+                testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
+            MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
+            for i in reversed(range(len(self.testarrayofstring))):
+                builder.PrependUOffsetTRelative(testarrayofstringlist[i])
+            testarrayofstring = builder.EndVector()
+        if self.testarrayoftables is not None:
+            testarrayoftableslist = []
+            for i in range(len(self.testarrayoftables)):
+                testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
+            MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
+            for i in reversed(range(len(self.testarrayoftables))):
+                builder.PrependUOffsetTRelative(testarrayoftableslist[i])
+            testarrayoftables = builder.EndVector()
+        if self.enemy is not None:
+            enemy = self.enemy.Pack(builder)
+        if self.testnestedflatbuffer is not None:
+            if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
+                testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
+            else:
+                MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
+                for i in reversed(range(len(self.testnestedflatbuffer))):
+                    builder.PrependUint8(self.testnestedflatbuffer[i])
+                testnestedflatbuffer = builder.EndVector()
+        if self.testempty is not None:
+            testempty = self.testempty.Pack(builder)
+        if self.testarrayofbools is not None:
+            if np is not None and type(self.testarrayofbools) is np.ndarray:
+                testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
+            else:
+                MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
+                for i in reversed(range(len(self.testarrayofbools))):
+                    builder.PrependBool(self.testarrayofbools[i])
+                testarrayofbools = builder.EndVector()
+        if self.testarrayofstring2 is not None:
+            testarrayofstring2list = []
+            for i in range(len(self.testarrayofstring2)):
+                testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
+            MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
+            for i in reversed(range(len(self.testarrayofstring2))):
+                builder.PrependUOffsetTRelative(testarrayofstring2list[i])
+            testarrayofstring2 = builder.EndVector()
+        if self.testarrayofsortedstruct is not None:
+            MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
+            for i in reversed(range(len(self.testarrayofsortedstruct))):
+                self.testarrayofsortedstruct[i].Pack(builder)
+            testarrayofsortedstruct = builder.EndVector()
+        if self.flex is not None:
+            if np is not None and type(self.flex) is np.ndarray:
+                flex = builder.CreateNumpyVector(self.flex)
+            else:
+                MonsterStartFlexVector(builder, len(self.flex))
+                for i in reversed(range(len(self.flex))):
+                    builder.PrependUint8(self.flex[i])
+                flex = builder.EndVector()
+        if self.test5 is not None:
+            MonsterStartTest5Vector(builder, len(self.test5))
+            for i in reversed(range(len(self.test5))):
+                self.test5[i].Pack(builder)
+            test5 = builder.EndVector()
+        if self.vectorOfLongs is not None:
+            if np is not None and type(self.vectorOfLongs) is np.ndarray:
+                vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
+            else:
+                MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
+                for i in reversed(range(len(self.vectorOfLongs))):
+                    builder.PrependInt64(self.vectorOfLongs[i])
+                vectorOfLongs = builder.EndVector()
+        if self.vectorOfDoubles is not None:
+            if np is not None and type(self.vectorOfDoubles) is np.ndarray:
+                vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
+            else:
+                MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
+                for i in reversed(range(len(self.vectorOfDoubles))):
+                    builder.PrependFloat64(self.vectorOfDoubles[i])
+                vectorOfDoubles = builder.EndVector()
+        if self.parentNamespaceTest is not None:
+            parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
+        if self.vectorOfReferrables is not None:
+            vectorOfReferrableslist = []
+            for i in range(len(self.vectorOfReferrables)):
+                vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
+            MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
+            for i in reversed(range(len(self.vectorOfReferrables))):
+                builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
+            vectorOfReferrables = builder.EndVector()
+        if self.vectorOfWeakReferences is not None:
+            if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
+                vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
+            else:
+                MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
+                for i in reversed(range(len(self.vectorOfWeakReferences))):
+                    builder.PrependUint64(self.vectorOfWeakReferences[i])
+                vectorOfWeakReferences = builder.EndVector()
+        if self.vectorOfStrongReferrables is not None:
+            vectorOfStrongReferrableslist = []
+            for i in range(len(self.vectorOfStrongReferrables)):
+                vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
+            MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
+            for i in reversed(range(len(self.vectorOfStrongReferrables))):
+                builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
+            vectorOfStrongReferrables = builder.EndVector()
+        if self.vectorOfCoOwningReferences is not None:
+            if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
+                vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
+            else:
+                MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
+                for i in reversed(range(len(self.vectorOfCoOwningReferences))):
+                    builder.PrependUint64(self.vectorOfCoOwningReferences[i])
+                vectorOfCoOwningReferences = builder.EndVector()
+        if self.vectorOfNonOwningReferences is not None:
+            if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
+                vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
+            else:
+                MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
+                for i in reversed(range(len(self.vectorOfNonOwningReferences))):
+                    builder.PrependUint64(self.vectorOfNonOwningReferences[i])
+                vectorOfNonOwningReferences = builder.EndVector()
+        if self.anyUnique is not None:
+            anyUnique = self.anyUnique.Pack(builder)
+        if self.anyAmbiguous is not None:
+            anyAmbiguous = self.anyAmbiguous.Pack(builder)
+        if self.vectorOfEnums is not None:
+            if np is not None and type(self.vectorOfEnums) is np.ndarray:
+                vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
+            else:
+                MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
+                for i in reversed(range(len(self.vectorOfEnums))):
+                    builder.PrependUint8(self.vectorOfEnums[i])
+                vectorOfEnums = builder.EndVector()
+        if self.testrequirednestedflatbuffer is not None:
+            if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
+                testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
+            else:
+                MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
+                for i in reversed(range(len(self.testrequirednestedflatbuffer))):
+                    builder.PrependUint8(self.testrequirednestedflatbuffer[i])
+                testrequirednestedflatbuffer = builder.EndVector()
+        if self.scalarKeySortedTables is not None:
+            scalarKeySortedTableslist = []
+            for i in range(len(self.scalarKeySortedTables)):
+                scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
+            MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
+            for i in reversed(range(len(self.scalarKeySortedTables))):
+                builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
+            scalarKeySortedTables = builder.EndVector()
+        MonsterStart(builder)
+        if self.pos is not None:
+            pos = self.pos.Pack(builder)
+            MonsterAddPos(builder, pos)
+        MonsterAddMana(builder, self.mana)
+        MonsterAddHp(builder, self.hp)
+        if self.name is not None:
+            MonsterAddName(builder, name)
+        if self.inventory is not None:
+            MonsterAddInventory(builder, inventory)
+        MonsterAddColor(builder, self.color)
+        MonsterAddTestType(builder, self.testType)
+        if self.test is not None:
+            MonsterAddTest(builder, test)
+        if self.test4 is not None:
+            MonsterAddTest4(builder, test4)
+        if self.testarrayofstring is not None:
+            MonsterAddTestarrayofstring(builder, testarrayofstring)
+        if self.testarrayoftables is not None:
+            MonsterAddTestarrayoftables(builder, testarrayoftables)
+        if self.enemy is not None:
+            MonsterAddEnemy(builder, enemy)
+        if self.testnestedflatbuffer is not None:
+            MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
+        if self.testempty is not None:
+            MonsterAddTestempty(builder, testempty)
+        MonsterAddTestbool(builder, self.testbool)
+        MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
+        MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
+        MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
+        MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
+        MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
+        MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
+        MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
+        MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
+        if self.testarrayofbools is not None:
+            MonsterAddTestarrayofbools(builder, testarrayofbools)
+        MonsterAddTestf(builder, self.testf)
+        MonsterAddTestf2(builder, self.testf2)
+        MonsterAddTestf3(builder, self.testf3)
+        if self.testarrayofstring2 is not None:
+            MonsterAddTestarrayofstring2(builder, testarrayofstring2)
+        if self.testarrayofsortedstruct is not None:
+            MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
+        if self.flex is not None:
+            MonsterAddFlex(builder, flex)
+        if self.test5 is not None:
+            MonsterAddTest5(builder, test5)
+        if self.vectorOfLongs is not None:
+            MonsterAddVectorOfLongs(builder, vectorOfLongs)
+        if self.vectorOfDoubles is not None:
+            MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
+        if self.parentNamespaceTest is not None:
+            MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
+        if self.vectorOfReferrables is not None:
+            MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
+        MonsterAddSingleWeakReference(builder, self.singleWeakReference)
+        if self.vectorOfWeakReferences is not None:
+            MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
+        if self.vectorOfStrongReferrables is not None:
+            MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
+        MonsterAddCoOwningReference(builder, self.coOwningReference)
+        if self.vectorOfCoOwningReferences is not None:
+            MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
+        MonsterAddNonOwningReference(builder, self.nonOwningReference)
+        if self.vectorOfNonOwningReferences is not None:
+            MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
+        MonsterAddAnyUniqueType(builder, self.anyUniqueType)
+        if self.anyUnique is not None:
+            MonsterAddAnyUnique(builder, anyUnique)
+        MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
+        if self.anyAmbiguous is not None:
+            MonsterAddAnyAmbiguous(builder, anyAmbiguous)
+        if self.vectorOfEnums is not None:
+            MonsterAddVectorOfEnums(builder, vectorOfEnums)
+        MonsterAddSignedEnum(builder, self.signedEnum)
+        if self.testrequirednestedflatbuffer is not None:
+            MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
+        if self.scalarKeySortedTables is not None:
+            MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
+        monster = MonsterEnd(builder)
+        return monster
+
+
+class TypeAliases(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = TypeAliases()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsTypeAliases(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def TypeAliasesBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
+
+    # TypeAliases
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # TypeAliases
+    def I8(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # TypeAliases
+    def U8(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # TypeAliases
+    def I16(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
+        return 0
+
+    # TypeAliases
+    def U16(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # TypeAliases
+    def I32(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # TypeAliases
+    def U32(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # TypeAliases
+    def I64(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # TypeAliases
+    def U64(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # TypeAliases
+    def F32(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # TypeAliases
+    def F64(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # TypeAliases
+    def V8(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # TypeAliases
+    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
+    def V8IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+    # TypeAliases
+    def Vf64(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # TypeAliases
+    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
+    def Vf64IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
+
+def TypeAliasesStart(builder): builder.StartObject(12)
+def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
+def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
+def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
+def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
+def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
+def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
+def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
+def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
+def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
+def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
+def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
+def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
+def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def TypeAliasesEnd(builder): return builder.EndObject()
+
+try:
+    from typing import List
+except:
+    pass
+
+class TypeAliasesT(object):
+
+    # TypeAliasesT
+    def __init__(self):
+        self.i8 = 0  # type: int
+        self.u8 = 0  # type: int
+        self.i16 = 0  # type: int
+        self.u16 = 0  # type: int
+        self.i32 = 0  # type: int
+        self.u32 = 0  # type: int
+        self.i64 = 0  # type: int
+        self.u64 = 0  # type: int
+        self.f32 = 0.0  # type: float
+        self.f64 = 0.0  # type: float
+        self.v8 = None  # type: List[int]
+        self.vf64 = None  # type: List[float]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        typeAliases = TypeAliases()
+        typeAliases.Init(buf, pos)
+        return cls.InitFromObj(typeAliases)
+
+    @classmethod
+    def InitFromObj(cls, typeAliases):
+        x = TypeAliasesT()
+        x._UnPack(typeAliases)
+        return x
+
+    # TypeAliasesT
+    def _UnPack(self, typeAliases):
+        if typeAliases is None:
+            return
+        self.i8 = typeAliases.I8()
+        self.u8 = typeAliases.U8()
+        self.i16 = typeAliases.I16()
+        self.u16 = typeAliases.U16()
+        self.i32 = typeAliases.I32()
+        self.u32 = typeAliases.U32()
+        self.i64 = typeAliases.I64()
+        self.u64 = typeAliases.U64()
+        self.f32 = typeAliases.F32()
+        self.f64 = typeAliases.F64()
+        if not typeAliases.V8IsNone():
+            if np is None:
+                self.v8 = []
+                for i in range(typeAliases.V8Length()):
+                    self.v8.append(typeAliases.V8(i))
+            else:
+                self.v8 = typeAliases.V8AsNumpy()
+        if not typeAliases.Vf64IsNone():
+            if np is None:
+                self.vf64 = []
+                for i in range(typeAliases.Vf64Length()):
+                    self.vf64.append(typeAliases.Vf64(i))
+            else:
+                self.vf64 = typeAliases.Vf64AsNumpy()
+
+    # TypeAliasesT
+    def Pack(self, builder):
+        if self.v8 is not None:
+            if np is not None and type(self.v8) is np.ndarray:
+                v8 = builder.CreateNumpyVector(self.v8)
+            else:
+                TypeAliasesStartV8Vector(builder, len(self.v8))
+                for i in reversed(range(len(self.v8))):
+                    builder.PrependByte(self.v8[i])
+                v8 = builder.EndVector()
+        if self.vf64 is not None:
+            if np is not None and type(self.vf64) is np.ndarray:
+                vf64 = builder.CreateNumpyVector(self.vf64)
+            else:
+                TypeAliasesStartVf64Vector(builder, len(self.vf64))
+                for i in reversed(range(len(self.vf64))):
+                    builder.PrependFloat64(self.vf64[i])
+                vf64 = builder.EndVector()
+        TypeAliasesStart(builder)
+        TypeAliasesAddI8(builder, self.i8)
+        TypeAliasesAddU8(builder, self.u8)
+        TypeAliasesAddI16(builder, self.i16)
+        TypeAliasesAddU16(builder, self.u16)
+        TypeAliasesAddI32(builder, self.i32)
+        TypeAliasesAddU32(builder, self.u32)
+        TypeAliasesAddI64(builder, self.i64)
+        TypeAliasesAddU64(builder, self.u64)
+        TypeAliasesAddF32(builder, self.f32)
+        TypeAliasesAddF64(builder, self.f64)
+        if self.v8 is not None:
+            TypeAliasesAddV8(builder, v8)
+        if self.vf64 is not None:
+            TypeAliasesAddVf64(builder, vf64)
+        typeAliases = TypeAliasesEnd(builder)
+        return typeAliases
+
+
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.py b/tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.py
index cb8218f0d..ae74c5477 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.py
+++ b/tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.py
@@ -6,4 +6,3 @@ class EnumInNestedNS(object):
     A = 0
     B = 1
     C = 2
-
diff --git a/tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.py b/tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.py
index 32b16b9f1..af601c7c4 100644
--- a/tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.py
+++ b/tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.py
@@ -6,7 +6,6 @@ class UnionInNestedNS(object):
     NONE = 0
     TableInNestedNS = 1
 
-
 def UnionInNestedNSCreator(unionType, table):
     from flatbuffers.table import Table
     if not isinstance(table, Table):
diff --git a/tests/py_test.py b/tests/py_test.py
index a5d40fa59..ed966d51d 100644
--- a/tests/py_test.py
+++ b/tests/py_test.py
@@ -42,1452 +42,1839 @@ import MyGame.Example.Test  # refers to generated code
 import MyGame.Example.Stat  # refers to generated code
 import MyGame.Example.Vec3  # refers to generated code
 import MyGame.MonsterExtra  # refers to generated code
-import MyGame.InParentNamespace # refers to generated code
+import MyGame.InParentNamespace  # refers to generated code
 import MyGame.Example.ArrayTable  # refers to generated code
 import MyGame.Example.ArrayStruct  # refers to generated code
 import MyGame.Example.NestedStruct  # refers to generated code
 import MyGame.Example.TestEnum  # refers to generated code
+import monster_test_generated  # the one-file version
+
+
+def create_namespace_shortcut(is_onefile):
+  # Create shortcut from either the one-file format or the multi-file format
+  global _ANY
+  global _COLOR
+  global _MONSTER
+  global _TEST
+  global _STAT
+  global _VEC3
+  global _IN_PARENT_NAMESPACE
+  if is_onefile:
+    print('Testing with the one-file generated code')
+    _ANY = monster_test_generated
+    _COLOR = monster_test_generated
+    _MONSTER = monster_test_generated
+    _TEST = monster_test_generated
+    _STAT = monster_test_generated
+    _VEC3 = monster_test_generated
+    _IN_PARENT_NAMESPACE = monster_test_generated
+  else:
+    print('Testing with multi-file generated code')
+    _ANY = MyGame.Example.Any
+    _COLOR = MyGame.Example.Color
+    _MONSTER = MyGame.Example.Monster
+    _TEST = MyGame.Example.Test
+    _STAT = MyGame.Example.Stat
+    _VEC3 = MyGame.Example.Vec3
+    _IN_PARENT_NAMESPACE = MyGame.InParentNamespace
+
 
 def assertRaises(test_case, fn, exception_class):
-    ''' Backwards-compatible assertion for exceptions raised. '''
+  """ Backwards-compatible assertion for exceptions raised. """
 
-    exc = None
-    try:
-        fn()
-    except Exception as e:
-        exc = e
-    test_case.assertTrue(exc is not None)
-    test_case.assertTrue(isinstance(exc, exception_class))
+  exc = None
+  try:
+    fn()
+  except Exception as e:
+    exc = e
+  test_case.assertTrue(exc is not None)
+  test_case.assertTrue(isinstance(exc, exception_class))
 
 
 class TestWireFormat(unittest.TestCase):
-    def test_wire_format(self):
-        # Verify that using the generated Python code builds a buffer without
-        # returning errors, and is interpreted correctly, for size prefixed
-        # representation and regular:
-        for sizePrefix in [True, False]:
-            for file_identifier in [None, b"MONS"]:
-                gen_buf, gen_off = make_monster_from_generated_code(sizePrefix=sizePrefix, file_identifier=file_identifier)
-                CheckReadBuffer(gen_buf, gen_off, sizePrefix=sizePrefix, file_identifier=file_identifier)
 
-        # Verify that the canonical flatbuffer file is readable by the
-        # generated Python code. Note that context managers are not part of
-        # Python 2.5, so we use the simpler open/close methods here:
-        f = open('monsterdata_test.mon', 'rb')
-        canonicalWireData = f.read()
-        f.close()
-        CheckReadBuffer(bytearray(canonicalWireData), 0, file_identifier=b'MONS')
+  def test_wire_format(self):
+    # Verify that using the generated Python code builds a buffer without
+    # returning errors, and is interpreted correctly, for size prefixed
+    # representation and regular:
+    for sizePrefix in [True, False]:
+      for file_identifier in [None, b'MONS']:
+        gen_buf, gen_off = make_monster_from_generated_code(
+            sizePrefix=sizePrefix, file_identifier=file_identifier)
+        CheckReadBuffer(
+            gen_buf,
+            gen_off,
+            sizePrefix=sizePrefix,
+            file_identifier=file_identifier)
 
-        # Write the generated buffer out to a file:
-        f = open('monsterdata_python_wire.mon', 'wb')
-        f.write(gen_buf[gen_off:])
-        f.close()
+    # Verify that the canonical flatbuffer file is readable by the
+    # generated Python code. Note that context managers are not part of
+    # Python 2.5, so we use the simpler open/close methods here:
+    f = open('monsterdata_test.mon', 'rb')
+    canonicalWireData = f.read()
+    f.close()
+    CheckReadBuffer(bytearray(canonicalWireData), 0, file_identifier=b'MONS')
+
+    # Write the generated buffer out to a file:
+    f = open('monsterdata_python_wire.mon', 'wb')
+    f.write(gen_buf[gen_off:])
+    f.close()
 
 
 class TestObjectBasedAPI(unittest.TestCase):
-    ''' Tests the generated object based API.'''
+  """ Tests the generated object based API."""
+
+  def test_consistenty_with_repeated_pack_and_unpack(self):
+    """ Checks the serialization and deserialization between a buffer and
 
-    def test_consistenty_with_repeated_pack_and_unpack(self):
-        ''' Checks the serialization and deserialization between a buffer and
         its python object. It tests in the same way as the C++ object API test,
-        ObjectFlatBuffersTest in test.cpp. '''
+        ObjectFlatBuffersTest in test.cpp.
+    """
 
-        buf, off = make_monster_from_generated_code()
+    buf, off = make_monster_from_generated_code()
 
-        # Turns a buffer into Python object (T class).
-        monster1 = MyGame.Example.Monster.Monster.GetRootAs(buf, off)
-        monsterT1 = MyGame.Example.Monster.MonsterT.InitFromObj(monster1)
+    # Turns a buffer into Python object (T class).
+    monster1 = _MONSTER.Monster.GetRootAs(buf, off)
+    monsterT1 = _MONSTER.MonsterT.InitFromObj(monster1)
 
-        for sizePrefix in [True, False]:
-            # Re-serialize the data into a buffer.
-            b1 = flatbuffers.Builder(0)
-            if sizePrefix:
-                b1.FinishSizePrefixed(monsterT1.Pack(b1))
-            else:
-                b1.Finish(monsterT1.Pack(b1))
-            CheckReadBuffer(b1.Bytes, b1.Head(), sizePrefix)
+    for sizePrefix in [True, False]:
+      # Re-serialize the data into a buffer.
+      b1 = flatbuffers.Builder(0)
+      if sizePrefix:
+        b1.FinishSizePrefixed(monsterT1.Pack(b1))
+      else:
+        b1.Finish(monsterT1.Pack(b1))
+      CheckReadBuffer(b1.Bytes, b1.Head(), sizePrefix)
 
-        # Deserializes the buffer into Python object again.
-        monster2 = MyGame.Example.Monster.Monster.GetRootAs(b1.Bytes,
-                                                                   b1.Head())
-        # Re-serializes the data into a buffer for one more time.
-        monsterT2 = MyGame.Example.Monster.MonsterT.InitFromObj(monster2)
-        for sizePrefix in [True, False]:
-            # Re-serializes the data into a buffer
-            b2 = flatbuffers.Builder(0)
-            if sizePrefix:
-                b2.FinishSizePrefixed(monsterT2.Pack(b2))
-            else:
-                b2.Finish(monsterT2.Pack(b2))
-            CheckReadBuffer(b2.Bytes, b2.Head(), sizePrefix)
+    # Deserializes the buffer into Python object again.
+    monster2 = _MONSTER.Monster.GetRootAs(b1.Bytes, b1.Head())
+    # Re-serializes the data into a buffer for one more time.
+    monsterT2 = _MONSTER.MonsterT.InitFromObj(monster2)
+    for sizePrefix in [True, False]:
+      # Re-serializes the data into a buffer
+      b2 = flatbuffers.Builder(0)
+      if sizePrefix:
+        b2.FinishSizePrefixed(monsterT2.Pack(b2))
+      else:
+        b2.Finish(monsterT2.Pack(b2))
+      CheckReadBuffer(b2.Bytes, b2.Head(), sizePrefix)
+
+  def test_default_values_with_pack_and_unpack(self):
+    """ Serializes and deserializes between a buffer with default values (no
 
-    def test_default_values_with_pack_and_unpack(self):
-        ''' Serializes and deserializes between a buffer with default values (no
         specific values are filled when the buffer is created) and its python
-        object. '''
-        # Creates a flatbuffer with default values.
-        b1 = flatbuffers.Builder(0)
-        MyGame.Example.Monster.Start(b1)
-        gen_mon = MyGame.Example.Monster.End(b1)
-        b1.Finish(gen_mon)
+        object.
+    """
+    # Creates a flatbuffer with default values.
+    b1 = flatbuffers.Builder(0)
+    _MONSTER.MonsterStart(b1)
+    gen_mon = _MONSTER.MonsterEnd(b1)
+    b1.Finish(gen_mon)
 
-        # Converts the flatbuffer into the object class.
-        monster1 = MyGame.Example.Monster.Monster.GetRootAs(b1.Bytes,
-                                                                   b1.Head())
-        monsterT1 = MyGame.Example.Monster.MonsterT.InitFromObj(monster1)
+    # Converts the flatbuffer into the object class.
+    monster1 = _MONSTER.Monster.GetRootAs(b1.Bytes, b1.Head())
+    monsterT1 = _MONSTER.MonsterT.InitFromObj(monster1)
 
-        # Packs the object class into another flatbuffer.
-        b2 = flatbuffers.Builder(0)
-        b2.Finish(monsterT1.Pack(b2))
-        monster2 = MyGame.Example.Monster.Monster.GetRootAs(b2.Bytes,
-                                                                   b2.Head())
-        # Checks the default values.
-        self.assertTrue(monster2.Pos() is None)
-        self.assertEqual(monster2.Mana(),150)
-        self.assertEqual(monster2.Hp(), 100)
-        self.assertTrue(monster2.Name() is None)
-        self.assertEqual(monster2.Inventory(0), 0)
-        self.assertEqual(monster2.InventoryAsNumpy(), 0)
-        self.assertEqual(monster2.InventoryLength(), 0)
-        self.assertTrue(monster2.InventoryIsNone())
-        self.assertTrue(monster2.Color() is 8)
-        self.assertEqual(monster2.TestType(), 0)
-        self.assertTrue(monster2.Test() is None)
-        self.assertTrue(monster2.Test4(0) is None)
-        self.assertEqual(monster2.Test4Length(), 0)
-        self.assertTrue(monster2.Test4IsNone())
-        self.assertTrue(monster2.Testarrayofstring(0) is "")
-        self.assertEqual(monster2.TestarrayofstringLength(), 0)
-        self.assertTrue(monster2.TestarrayofstringIsNone())
-        self.assertTrue(monster2.Testarrayoftables(0) is None)
-        self.assertEqual(monster2.TestarrayoftablesLength(), 0)
-        self.assertTrue(monster2.TestarrayoftablesIsNone())
-        self.assertTrue(monster2.Enemy() is None)
-        self.assertEqual(monster2.Testnestedflatbuffer(0), 0)
-        self.assertEqual(monster2.TestnestedflatbufferAsNumpy(), 0)
-        self.assertEqual(monster2.TestnestedflatbufferLength(), 0)
-        self.assertTrue(monster2.TestnestedflatbufferIsNone())
-        self.assertTrue(monster2.Testempty() is None)
-        self.assertTrue(monster2.Testbool() is False)
-        self.assertEqual(monster2.Testhashs32Fnv1(), 0)
-        self.assertEqual(monster2.Testhashu32Fnv1(), 0)
-        self.assertEqual(monster2.Testhashs64Fnv1(), 0)
-        self.assertEqual(monster2.Testhashu64Fnv1(), 0)
-        self.assertEqual(monster2.Testhashs32Fnv1a(), 0)
-        self.assertEqual(monster2.Testhashu32Fnv1a(), 0)
-        self.assertEqual(monster2.Testhashs64Fnv1a(), 0)
-        self.assertEqual(monster2.Testhashu64Fnv1a(), 0)
-        self.assertEqual(monster2.Testarrayofbools(0), 0)
-        self.assertEqual(monster2.TestarrayofboolsAsNumpy(), 0)
-        self.assertEqual(monster2.TestarrayofboolsLength(), 0)
-        self.assertTrue(monster2.TestarrayofboolsIsNone())
-        self.assertEqual(monster2.Testf(), 3.14159)
-        self.assertEqual(monster2.Testf2(), 3.0)
-        self.assertEqual(monster2.Testf3(), 0.0)
-        self.assertTrue(monster2.Testarrayofstring2(0) is "")
-        self.assertEqual(monster2.Testarrayofstring2Length(), 0)
-        self.assertTrue(monster2.Testarrayofstring2IsNone())
-        self.assertTrue(monster2.Testarrayofsortedstruct(0) is None)
-        self.assertEqual(monster2.TestarrayofsortedstructLength(), 0)
-        self.assertTrue(monster2.TestarrayofsortedstructIsNone())
-        self.assertEqual(monster2.Flex(0), 0)
-        self.assertEqual(monster2.FlexAsNumpy(), 0)
-        self.assertEqual(monster2.FlexLength(), 0)
-        self.assertTrue(monster2.FlexIsNone())
-        self.assertTrue(monster2.Test5(0) is None)
-        self.assertEqual(monster2.Test5Length(), 0)
-        self.assertTrue(monster2.Test5IsNone())
-        self.assertEqual(monster2.VectorOfLongs(0), 0)
-        self.assertEqual(monster2.VectorOfLongsAsNumpy(), 0)
-        self.assertEqual(monster2.VectorOfLongsLength(), 0)
-        self.assertTrue(monster2.VectorOfLongsIsNone())
-        self.assertEqual(monster2.VectorOfDoubles(0), 0)
-        self.assertEqual(monster2.VectorOfDoublesAsNumpy(), 0)
-        self.assertEqual(monster2.VectorOfDoublesLength(), 0)
-        self.assertTrue(monster2.VectorOfDoublesIsNone())
-        self.assertTrue(monster2.ParentNamespaceTest() is None)
-        self.assertTrue(monster2.VectorOfReferrables(0) is None)
-        self.assertEqual(monster2.VectorOfReferrablesLength(), 0)
-        self.assertTrue(monster2.VectorOfReferrablesIsNone())
-        self.assertEqual(monster2.SingleWeakReference(), 0)
-        self.assertEqual(monster2.VectorOfWeakReferences(0), 0)
-        self.assertEqual(monster2.VectorOfWeakReferencesAsNumpy(), 0)
-        self.assertEqual(monster2.VectorOfWeakReferencesLength(), 0)
-        self.assertTrue(monster2.VectorOfWeakReferencesIsNone())
-        self.assertTrue(monster2.VectorOfStrongReferrables(0) is None)
-        self.assertEqual(monster2.VectorOfStrongReferrablesLength(), 0)
-        self.assertTrue(monster2.VectorOfStrongReferrablesIsNone())
-        self.assertEqual(monster2.CoOwningReference(), 0)
-        self.assertEqual(monster2.VectorOfCoOwningReferences(0), 0)
-        self.assertEqual(monster2.VectorOfCoOwningReferencesAsNumpy(), 0)
-        self.assertEqual(monster2.VectorOfCoOwningReferencesLength(), 0)
-        self.assertTrue(monster2.VectorOfCoOwningReferencesIsNone())
-        self.assertEqual(monster2.NonOwningReference(), 0)
-        self.assertEqual(monster2.VectorOfNonOwningReferences(0), 0)
-        self.assertEqual(monster2.VectorOfNonOwningReferencesAsNumpy(), 0)
-        self.assertEqual(monster2.VectorOfNonOwningReferencesLength(), 0)
-        self.assertTrue(monster2.VectorOfNonOwningReferencesIsNone())
-        self.assertEqual(monster2.AnyUniqueType(), 0)
-        self.assertTrue(monster2.AnyUnique() is None)
-        self.assertEqual(monster2.AnyAmbiguousType(), 0)
-        self.assertTrue(monster2.AnyAmbiguous() is None)
-        self.assertEqual(monster2.VectorOfEnums(0), 0)
-        self.assertEqual(monster2.VectorOfEnumsAsNumpy(), 0)
-        self.assertEqual(monster2.VectorOfEnumsLength(), 0)
-        self.assertTrue(monster2.VectorOfEnumsIsNone())
+    # Packs the object class into another flatbuffer.
+    b2 = flatbuffers.Builder(0)
+    b2.Finish(monsterT1.Pack(b2))
+    monster2 = _MONSTER.Monster.GetRootAs(b2.Bytes, b2.Head())
+    # Checks the default values.
+    self.assertTrue(monster2.Pos() is None)
+    self.assertEqual(monster2.Mana(), 150)
+    self.assertEqual(monster2.Hp(), 100)
+    self.assertTrue(monster2.Name() is None)
+    self.assertEqual(monster2.Inventory(0), 0)
+    self.assertEqual(monster2.InventoryAsNumpy(), 0)
+    self.assertEqual(monster2.InventoryLength(), 0)
+    self.assertTrue(monster2.InventoryIsNone())
+    self.assertTrue(monster2.Color() is 8)
+    self.assertEqual(monster2.TestType(), 0)
+    self.assertTrue(monster2.Test() is None)
+    self.assertTrue(monster2.Test4(0) is None)
+    self.assertEqual(monster2.Test4Length(), 0)
+    self.assertTrue(monster2.Test4IsNone())
+    self.assertTrue(monster2.Testarrayofstring(0) is '')
+    self.assertEqual(monster2.TestarrayofstringLength(), 0)
+    self.assertTrue(monster2.TestarrayofstringIsNone())
+    self.assertTrue(monster2.Testarrayoftables(0) is None)
+    self.assertEqual(monster2.TestarrayoftablesLength(), 0)
+    self.assertTrue(monster2.TestarrayoftablesIsNone())
+    self.assertTrue(monster2.Enemy() is None)
+    self.assertEqual(monster2.Testnestedflatbuffer(0), 0)
+    self.assertEqual(monster2.TestnestedflatbufferAsNumpy(), 0)
+    self.assertEqual(monster2.TestnestedflatbufferLength(), 0)
+    self.assertTrue(monster2.TestnestedflatbufferIsNone())
+    self.assertTrue(monster2.Testempty() is None)
+    self.assertTrue(monster2.Testbool() is False)
+    self.assertEqual(monster2.Testhashs32Fnv1(), 0)
+    self.assertEqual(monster2.Testhashu32Fnv1(), 0)
+    self.assertEqual(monster2.Testhashs64Fnv1(), 0)
+    self.assertEqual(monster2.Testhashu64Fnv1(), 0)
+    self.assertEqual(monster2.Testhashs32Fnv1a(), 0)
+    self.assertEqual(monster2.Testhashu32Fnv1a(), 0)
+    self.assertEqual(monster2.Testhashs64Fnv1a(), 0)
+    self.assertEqual(monster2.Testhashu64Fnv1a(), 0)
+    self.assertEqual(monster2.Testarrayofbools(0), 0)
+    self.assertEqual(monster2.TestarrayofboolsAsNumpy(), 0)
+    self.assertEqual(monster2.TestarrayofboolsLength(), 0)
+    self.assertTrue(monster2.TestarrayofboolsIsNone())
+    self.assertEqual(monster2.Testf(), 3.14159)
+    self.assertEqual(monster2.Testf2(), 3.0)
+    self.assertEqual(monster2.Testf3(), 0.0)
+    self.assertTrue(monster2.Testarrayofstring2(0) is '')
+    self.assertEqual(monster2.Testarrayofstring2Length(), 0)
+    self.assertTrue(monster2.Testarrayofstring2IsNone())
+    self.assertTrue(monster2.Testarrayofsortedstruct(0) is None)
+    self.assertEqual(monster2.TestarrayofsortedstructLength(), 0)
+    self.assertTrue(monster2.TestarrayofsortedstructIsNone())
+    self.assertEqual(monster2.Flex(0), 0)
+    self.assertEqual(monster2.FlexAsNumpy(), 0)
+    self.assertEqual(monster2.FlexLength(), 0)
+    self.assertTrue(monster2.FlexIsNone())
+    self.assertTrue(monster2.Test5(0) is None)
+    self.assertEqual(monster2.Test5Length(), 0)
+    self.assertTrue(monster2.Test5IsNone())
+    self.assertEqual(monster2.VectorOfLongs(0), 0)
+    self.assertEqual(monster2.VectorOfLongsAsNumpy(), 0)
+    self.assertEqual(monster2.VectorOfLongsLength(), 0)
+    self.assertTrue(monster2.VectorOfLongsIsNone())
+    self.assertEqual(monster2.VectorOfDoubles(0), 0)
+    self.assertEqual(monster2.VectorOfDoublesAsNumpy(), 0)
+    self.assertEqual(monster2.VectorOfDoublesLength(), 0)
+    self.assertTrue(monster2.VectorOfDoublesIsNone())
+    self.assertTrue(monster2.ParentNamespaceTest() is None)
+    self.assertTrue(monster2.VectorOfReferrables(0) is None)
+    self.assertEqual(monster2.VectorOfReferrablesLength(), 0)
+    self.assertTrue(monster2.VectorOfReferrablesIsNone())
+    self.assertEqual(monster2.SingleWeakReference(), 0)
+    self.assertEqual(monster2.VectorOfWeakReferences(0), 0)
+    self.assertEqual(monster2.VectorOfWeakReferencesAsNumpy(), 0)
+    self.assertEqual(monster2.VectorOfWeakReferencesLength(), 0)
+    self.assertTrue(monster2.VectorOfWeakReferencesIsNone())
+    self.assertTrue(monster2.VectorOfStrongReferrables(0) is None)
+    self.assertEqual(monster2.VectorOfStrongReferrablesLength(), 0)
+    self.assertTrue(monster2.VectorOfStrongReferrablesIsNone())
+    self.assertEqual(monster2.CoOwningReference(), 0)
+    self.assertEqual(monster2.VectorOfCoOwningReferences(0), 0)
+    self.assertEqual(monster2.VectorOfCoOwningReferencesAsNumpy(), 0)
+    self.assertEqual(monster2.VectorOfCoOwningReferencesLength(), 0)
+    self.assertTrue(monster2.VectorOfCoOwningReferencesIsNone())
+    self.assertEqual(monster2.NonOwningReference(), 0)
+    self.assertEqual(monster2.VectorOfNonOwningReferences(0), 0)
+    self.assertEqual(monster2.VectorOfNonOwningReferencesAsNumpy(), 0)
+    self.assertEqual(monster2.VectorOfNonOwningReferencesLength(), 0)
+    self.assertTrue(monster2.VectorOfNonOwningReferencesIsNone())
+    self.assertEqual(monster2.AnyUniqueType(), 0)
+    self.assertTrue(monster2.AnyUnique() is None)
+    self.assertEqual(monster2.AnyAmbiguousType(), 0)
+    self.assertTrue(monster2.AnyAmbiguous() is None)
+    self.assertEqual(monster2.VectorOfEnums(0), 0)
+    self.assertEqual(monster2.VectorOfEnumsAsNumpy(), 0)
+    self.assertEqual(monster2.VectorOfEnumsLength(), 0)
+    self.assertTrue(monster2.VectorOfEnumsIsNone())
 
 
 class TestAllMutableCodePathsOfExampleSchema(unittest.TestCase):
-    ''' Tests the object API generated for monster_test.fbs for mutation
+  """ Tests the object API generated for monster_test.fbs for mutation
+
         purposes. In each test, the default values will be changed through the
         object API. We'll then pack the object class into the buf class and read
         the updated values out from it to validate if the values are mutated as
-        expected.'''
+        expected.
+  """
 
-    def setUp(self, *args, **kwargs):
-        super(TestAllMutableCodePathsOfExampleSchema, self).setUp(*args,
-                                                                  **kwargs)
-        # Creates an empty monster flatbuffer, and loads it into the object
-        # class for future tests.
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.Start(b)
-        self.monsterT = self._create_and_load_object_class(b)
+  def setUp(self, *args, **kwargs):
+    super(TestAllMutableCodePathsOfExampleSchema, self).setUp(*args, **kwargs)
+    # Creates an empty monster flatbuffer, and loads it into the object
+    # class for future tests.
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStart(b)
+    self.monsterT = self._create_and_load_object_class(b)
 
-    def _pack_and_load_buf_class(self, monsterT):
-        ''' Packs the object class into a flatbuffer and loads it into a buf
-        class.'''
-        b = flatbuffers.Builder(0)
-        b.Finish(monsterT.Pack(b))
-        monster = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                                  b.Head())
-        return monster
+  def _pack_and_load_buf_class(self, monsterT):
+    """ Packs the object class into a flatbuffer and loads it into a buf
 
-    def _create_and_load_object_class(self, b):
-        ''' Finishs the creation of a monster flatbuffer and loads it into an
-        object class.'''
-        gen_mon = MyGame.Example.Monster.End(b)
-        b.Finish(gen_mon)
-        monster = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                                  b.Head())
-        monsterT = MyGame.Example.Monster.MonsterT()
-        monsterT.InitFromObj(monster)
-        return monsterT
+        class.
+    """
+    b = flatbuffers.Builder(0)
+    b.Finish(monsterT.Pack(b))
+    monster = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    return monster
 
-    def test_mutate_pos(self):
-        posT = MyGame.Example.Vec3.Vec3T()
-        posT.x = 4.0
-        posT.y = 5.0
-        posT.z = 6.0
-        posT.test1 = 6.0
-        posT.test2 = 7
-        test3T = MyGame.Example.Test.TestT()
-        test3T.a = 8
-        test3T.b = 9
-        posT.test3 = test3T
-        self.monsterT.pos = posT
+  def _create_and_load_object_class(self, b):
+    """ Finishs the creation of a monster flatbuffer and loads it into an
 
-        # Packs the updated values.
-        monster = self._pack_and_load_buf_class(self.monsterT)
+        object class.
+    """
+    gen_mon = _MONSTER.MonsterEnd(b)
+    b.Finish(gen_mon)
+    monster = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    monsterT = _MONSTER.MonsterT()
+    monsterT.InitFromObj(monster)
+    return monsterT
 
-        # Checks if values are loaded correctly into the object class.
-        pos = monster.Pos()
+  def test_mutate_pos(self):
+    posT = _VEC3.Vec3T()
+    posT.x = 4.0
+    posT.y = 5.0
+    posT.z = 6.0
+    posT.test1 = 6.0
+    posT.test2 = 7
+    test3T = _TEST.TestT()
+    test3T.a = 8
+    test3T.b = 9
+    posT.test3 = test3T
+    self.monsterT.pos = posT
 
-        # Verifies the properties of the Vec3.
-        self.assertEqual(pos.X(), 4.0)
-        self.assertEqual(pos.Y(), 5.0)
-        self.assertEqual(pos.Z(), 6.0)
-        self.assertEqual(pos.Test1(), 6.0)
-        self.assertEqual(pos.Test2(), 7)
-        t3 = MyGame.Example.Test.Test()
-        t3 = pos.Test3(t3)
-        self.assertEqual(t3.A(), 8)
-        self.assertEqual(t3.B(), 9)
+    # Packs the updated values.
+    monster = self._pack_and_load_buf_class(self.monsterT)
 
-    def test_mutate_mana(self):
-        self.monsterT.mana = 200
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Mana(), 200)
+    # Checks if values are loaded correctly into the object class.
+    pos = monster.Pos()
 
-    def test_mutate_hp(self):
-        self.monsterT.hp = 200
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Hp(), 200)
+    # Verifies the properties of the Vec3.
+    self.assertEqual(pos.X(), 4.0)
+    self.assertEqual(pos.Y(), 5.0)
+    self.assertEqual(pos.Z(), 6.0)
+    self.assertEqual(pos.Test1(), 6.0)
+    self.assertEqual(pos.Test2(), 7)
+    t3 = _TEST.Test()
+    t3 = pos.Test3(t3)
+    self.assertEqual(t3.A(), 8)
+    self.assertEqual(t3.B(), 9)
 
-    def test_mutate_name(self):
-        self.monsterT.name = "MyMonster"
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Name(), b"MyMonster")
+  def test_mutate_mana(self):
+    self.monsterT.mana = 200
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Mana(), 200)
 
-    def test_mutate_inventory(self):
-        self.monsterT.inventory = [1, 7, 8]
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Inventory(0), 1)
-        self.assertEqual(monster.Inventory(1), 7)
-        self.assertEqual(monster.Inventory(2), 8)
+  def test_mutate_hp(self):
+    self.monsterT.hp = 200
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Hp(), 200)
 
-    def test_empty_inventory(self):
-        self.monsterT.inventory = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.InventoryIsNone())
+  def test_mutate_name(self):
+    self.monsterT.name = 'MyMonster'
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Name(), b'MyMonster')
 
-    def test_mutate_color(self):
-        self.monsterT.color = MyGame.Example.Color.Color.Red
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Color(), MyGame.Example.Color.Color.Red)
+  def test_mutate_inventory(self):
+    self.monsterT.inventory = [1, 7, 8]
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Inventory(0), 1)
+    self.assertEqual(monster.Inventory(1), 7)
+    self.assertEqual(monster.Inventory(2), 8)
 
-    def test_mutate_testtype(self):
-        self.monsterT.testType = MyGame.Example.Any.Any.Monster
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.TestType(), MyGame.Example.Any.Any.Monster)
+  def test_empty_inventory(self):
+    self.monsterT.inventory = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.InventoryIsNone())
 
-    def test_mutate_test(self):
-        testT = MyGame.Example.Monster.MonsterT()
-        testT.hp = 200
-        self.monsterT.test = testT
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        # Initializes a Table from a union field Test(...).
-        table = monster.Test()
+  def test_mutate_color(self):
+    self.monsterT.color = _COLOR.Color.Red
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Color(), _COLOR.Color.Red)
 
-        # Initializes a Monster from the Table from the union.
-        test_monster = MyGame.Example.Monster.Monster()
-        test_monster.Init(table.Bytes, table.Pos)
-        self.assertEqual(test_monster.Hp(), 200)
+  def test_mutate_testtype(self):
+    self.monsterT.testType = _ANY.Any.Monster
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.TestType(), _ANY.Any.Monster)
 
-    def test_mutate_test4(self):
-        test0T = MyGame.Example.Test.TestT()
-        test0T.a = 10
-        test0T.b = 20
-        test1T = MyGame.Example.Test.TestT()
-        test1T.a = 30
-        test1T.b = 40
-        self.monsterT.test4 = [test0T, test1T]
+  def test_mutate_test(self):
+    testT = _MONSTER.MonsterT()
+    testT.hp = 200
+    self.monsterT.test = testT
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    # Initializes a Table from a union field Test(...).
+    table = monster.Test()
 
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        test0 = monster.Test4(0)
-        self.assertEqual(test0.A(), 10)
-        self.assertEqual(test0.B(), 20)
-        test1 = monster.Test4(1)
-        self.assertEqual(test1.A(), 30)
-        self.assertEqual(test1.B(), 40)
+    # Initializes a Monster from the Table from the union.
+    test_monster = _MONSTER.Monster()
+    test_monster.Init(table.Bytes, table.Pos)
+    self.assertEqual(test_monster.Hp(), 200)
 
-    def test_empty_test4(self):
-        self.monsterT.test4 = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.Test4IsNone())
+  def test_mutate_test4(self):
+    test0T = _TEST.TestT()
+    test0T.a = 10
+    test0T.b = 20
+    test1T = _TEST.TestT()
+    test1T.a = 30
+    test1T.b = 40
+    self.monsterT.test4 = [test0T, test1T]
 
-    def test_mutate_testarrayofstring(self):
-        self.monsterT.testarrayofstring = []
-        self.monsterT.testarrayofstring.append("test1")
-        self.monsterT.testarrayofstring.append("test2")
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Testarrayofstring(0), b"test1")
-        self.assertEqual(monster.Testarrayofstring(1), b"test2")
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    test0 = monster.Test4(0)
+    self.assertEqual(test0.A(), 10)
+    self.assertEqual(test0.B(), 20)
+    test1 = monster.Test4(1)
+    self.assertEqual(test1.A(), 30)
+    self.assertEqual(test1.B(), 40)
 
-    def test_empty_testarrayofstring(self):
-        self.monsterT.testarrayofstring = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.TestarrayofstringIsNone())
+  def test_empty_test4(self):
+    self.monsterT.test4 = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.Test4IsNone())
 
-    def test_mutate_testarrayoftables(self):
-        monsterT0 = MyGame.Example.Monster.MonsterT()
-        monsterT0.hp = 200
-        monsterT1 = MyGame.Example.Monster.MonsterT()
-        monsterT1.hp = 400
-        self.monsterT.testarrayoftables = []
-        self.monsterT.testarrayoftables.append(monsterT0)
-        self.monsterT.testarrayoftables.append(monsterT1)
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Testarrayoftables(0).Hp(), 200)
-        self.assertEqual(monster.Testarrayoftables(1).Hp(), 400)
+  def test_mutate_testarrayofstring(self):
+    self.monsterT.testarrayofstring = []
+    self.monsterT.testarrayofstring.append('test1')
+    self.monsterT.testarrayofstring.append('test2')
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Testarrayofstring(0), b'test1')
+    self.assertEqual(monster.Testarrayofstring(1), b'test2')
 
-    def test_empty_testarrayoftables(self):
-        self.monsterT.testarrayoftables = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.TestarrayoftablesIsNone())
+  def test_empty_testarrayofstring(self):
+    self.monsterT.testarrayofstring = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.TestarrayofstringIsNone())
 
-    def test_mutate_enemy(self):
-        monsterT = MyGame.Example.Monster.MonsterT()
-        monsterT.hp = 200
-        self.monsterT.enemy = monsterT
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Enemy().Hp(), 200)
+  def test_mutate_testarrayoftables(self):
+    monsterT0 = _MONSTER.MonsterT()
+    monsterT0.hp = 200
+    monsterT1 = _MONSTER.MonsterT()
+    monsterT1.hp = 400
+    self.monsterT.testarrayoftables = []
+    self.monsterT.testarrayoftables.append(monsterT0)
+    self.monsterT.testarrayoftables.append(monsterT1)
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Testarrayoftables(0).Hp(), 200)
+    self.assertEqual(monster.Testarrayoftables(1).Hp(), 400)
 
-    def test_mutate_testnestedflatbuffer(self):
-        self.monsterT.testnestedflatbuffer = [8, 2, 4]
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Testnestedflatbuffer(0), 8)
-        self.assertEqual(monster.Testnestedflatbuffer(1), 2)
-        self.assertEqual(monster.Testnestedflatbuffer(2), 4)
+  def test_empty_testarrayoftables(self):
+    self.monsterT.testarrayoftables = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.TestarrayoftablesIsNone())
 
-    def test_empty_testnestedflatbuffer(self):
-        self.monsterT.testnestedflatbuffer = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.TestnestedflatbufferIsNone())
+  def test_mutate_enemy(self):
+    monsterT = _MONSTER.MonsterT()
+    monsterT.hp = 200
+    self.monsterT.enemy = monsterT
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Enemy().Hp(), 200)
 
-    def test_mutate_testbool(self):
-        self.monsterT.testbool = True
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertTrue(monster.Testbool())
+  def test_mutate_testnestedflatbuffer(self):
+    self.monsterT.testnestedflatbuffer = [8, 2, 4]
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Testnestedflatbuffer(0), 8)
+    self.assertEqual(monster.Testnestedflatbuffer(1), 2)
+    self.assertEqual(monster.Testnestedflatbuffer(2), 4)
 
-    def test_mutate_testhashes(self):
-        self.monsterT.testhashs32Fnv1 = 1
-        self.monsterT.testhashu32Fnv1 = 2
-        self.monsterT.testhashs64Fnv1 = 3
-        self.monsterT.testhashu64Fnv1 = 4
-        self.monsterT.testhashs32Fnv1a = 5
-        self.monsterT.testhashu32Fnv1a = 6
-        self.monsterT.testhashs64Fnv1a = 7
-        self.monsterT.testhashu64Fnv1a = 8
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Testhashs32Fnv1(), 1)
-        self.assertEqual(monster.Testhashu32Fnv1(), 2)
-        self.assertEqual(monster.Testhashs64Fnv1(), 3)
-        self.assertEqual(monster.Testhashu64Fnv1(), 4)
-        self.assertEqual(monster.Testhashs32Fnv1a(), 5)
-        self.assertEqual(monster.Testhashu32Fnv1a(), 6)
-        self.assertEqual(monster.Testhashs64Fnv1a(), 7)
-        self.assertEqual(monster.Testhashu64Fnv1a(), 8)
+  def test_empty_testnestedflatbuffer(self):
+    self.monsterT.testnestedflatbuffer = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.TestnestedflatbufferIsNone())
 
-    def test_mutate_testarrayofbools(self):
-        self.monsterT.testarrayofbools = []
-        self.monsterT.testarrayofbools.append(True)
-        self.monsterT.testarrayofbools.append(True)
-        self.monsterT.testarrayofbools.append(False)
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Testarrayofbools(0), True)
-        self.assertEqual(monster.Testarrayofbools(1), True)
-        self.assertEqual(monster.Testarrayofbools(2), False)
+  def test_mutate_testbool(self):
+    self.monsterT.testbool = True
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertTrue(monster.Testbool())
 
-    def test_empty_testarrayofbools(self):
-        self.monsterT.testarrayofbools = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.TestarrayofboolsIsNone())
+  def test_mutate_testhashes(self):
+    self.monsterT.testhashs32Fnv1 = 1
+    self.monsterT.testhashu32Fnv1 = 2
+    self.monsterT.testhashs64Fnv1 = 3
+    self.monsterT.testhashu64Fnv1 = 4
+    self.monsterT.testhashs32Fnv1a = 5
+    self.monsterT.testhashu32Fnv1a = 6
+    self.monsterT.testhashs64Fnv1a = 7
+    self.monsterT.testhashu64Fnv1a = 8
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Testhashs32Fnv1(), 1)
+    self.assertEqual(monster.Testhashu32Fnv1(), 2)
+    self.assertEqual(monster.Testhashs64Fnv1(), 3)
+    self.assertEqual(monster.Testhashu64Fnv1(), 4)
+    self.assertEqual(monster.Testhashs32Fnv1a(), 5)
+    self.assertEqual(monster.Testhashu32Fnv1a(), 6)
+    self.assertEqual(monster.Testhashs64Fnv1a(), 7)
+    self.assertEqual(monster.Testhashu64Fnv1a(), 8)
 
-    def test_mutate_testf(self):
-        self.monsterT.testf = 2.0
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.Testf(), 2.0)
+  def test_mutate_testarrayofbools(self):
+    self.monsterT.testarrayofbools = []
+    self.monsterT.testarrayofbools.append(True)
+    self.monsterT.testarrayofbools.append(True)
+    self.monsterT.testarrayofbools.append(False)
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Testarrayofbools(0), True)
+    self.assertEqual(monster.Testarrayofbools(1), True)
+    self.assertEqual(monster.Testarrayofbools(2), False)
 
-    def test_mutate_vectoroflongs(self):
-        self.monsterT.vectorOfLongs = []
-        self.monsterT.vectorOfLongs.append(1)
-        self.monsterT.vectorOfLongs.append(100)
-        self.monsterT.vectorOfLongs.append(10000)
-        self.monsterT.vectorOfLongs.append(1000000)
-        self.monsterT.vectorOfLongs.append(100000000)
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.VectorOfLongs(0), 1)
-        self.assertEqual(monster.VectorOfLongs(1), 100)
-        self.assertEqual(monster.VectorOfLongs(2), 10000)
-        self.assertEqual(monster.VectorOfLongs(3), 1000000)
-        self.assertEqual(monster.VectorOfLongs(4), 100000000)
+  def test_empty_testarrayofbools(self):
+    self.monsterT.testarrayofbools = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.TestarrayofboolsIsNone())
 
-    def test_empty_vectoroflongs(self):
-        self.monsterT.vectorOfLongs = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.VectorOfLongsIsNone())
+  def test_mutate_testf(self):
+    self.monsterT.testf = 2.0
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.Testf(), 2.0)
 
-    def test_mutate_vectorofdoubles(self):
-        self.monsterT.vectorOfDoubles = []
-        self.monsterT.vectorOfDoubles.append(-1.7976931348623157e+308)
-        self.monsterT.vectorOfDoubles.append(0)
-        self.monsterT.vectorOfDoubles.append(1.7976931348623157e+308)
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.VectorOfDoubles(0), -1.7976931348623157e+308)
-        self.assertEqual(monster.VectorOfDoubles(1), 0)
-        self.assertEqual(monster.VectorOfDoubles(2), 1.7976931348623157e+308)
+  def test_mutate_vectoroflongs(self):
+    self.monsterT.vectorOfLongs = []
+    self.monsterT.vectorOfLongs.append(1)
+    self.monsterT.vectorOfLongs.append(100)
+    self.monsterT.vectorOfLongs.append(10000)
+    self.monsterT.vectorOfLongs.append(1000000)
+    self.monsterT.vectorOfLongs.append(100000000)
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.VectorOfLongs(0), 1)
+    self.assertEqual(monster.VectorOfLongs(1), 100)
+    self.assertEqual(monster.VectorOfLongs(2), 10000)
+    self.assertEqual(monster.VectorOfLongs(3), 1000000)
+    self.assertEqual(monster.VectorOfLongs(4), 100000000)
 
-    def test_empty_vectorofdoubles(self):
-        self.monsterT.vectorOfDoubles = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.VectorOfDoublesIsNone())
+  def test_empty_vectoroflongs(self):
+    self.monsterT.vectorOfLongs = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.VectorOfLongsIsNone())
 
-    def test_mutate_parentnamespacetest(self):
-        self.monsterT.parentNamespaceTest = MyGame.InParentNamespace.InParentNamespaceT()
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertTrue(isinstance(monster.ParentNamespaceTest(),
-                                   MyGame.InParentNamespace.InParentNamespace))
+  def test_mutate_vectorofdoubles(self):
+    self.monsterT.vectorOfDoubles = []
+    self.monsterT.vectorOfDoubles.append(-1.7976931348623157e+308)
+    self.monsterT.vectorOfDoubles.append(0)
+    self.monsterT.vectorOfDoubles.append(1.7976931348623157e+308)
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.VectorOfDoubles(0), -1.7976931348623157e+308)
+    self.assertEqual(monster.VectorOfDoubles(1), 0)
+    self.assertEqual(monster.VectorOfDoubles(2), 1.7976931348623157e+308)
 
-    def test_mutate_vectorofEnums(self):
-        self.monsterT.vectorOfEnums = []
-        self.monsterT.vectorOfEnums.append(MyGame.Example.Color.Color.Red)
-        self.monsterT.vectorOfEnums.append(MyGame.Example.Color.Color.Blue)
-        self.monsterT.vectorOfEnums.append(MyGame.Example.Color.Color.Red)
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertEqual(monster.VectorOfEnums(0),
-                         MyGame.Example.Color.Color.Red)
-        self.assertEqual(monster.VectorOfEnums(1),
-                         MyGame.Example.Color.Color.Blue)
-        self.assertEqual(monster.VectorOfEnums(2),
-                         MyGame.Example.Color.Color.Red)
+  def test_empty_vectorofdoubles(self):
+    self.monsterT.vectorOfDoubles = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.VectorOfDoublesIsNone())
 
-    def test_empty_vectorofEnums(self):
-        self.monsterT.vectorOfEnums = []
-        monster = self._pack_and_load_buf_class(self.monsterT)
-        self.assertFalse(monster.VectorOfEnumsIsNone())
+  def test_mutate_parentnamespacetest(self):
+    self.monsterT.parentNamespaceTest = _IN_PARENT_NAMESPACE.InParentNamespaceT(
+    )
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertTrue(
+        isinstance(monster.ParentNamespaceTest(),
+                   _IN_PARENT_NAMESPACE.InParentNamespace))
+
+  def test_mutate_vectorofEnums(self):
+    self.monsterT.vectorOfEnums = []
+    self.monsterT.vectorOfEnums.append(_COLOR.Color.Red)
+    self.monsterT.vectorOfEnums.append(_COLOR.Color.Blue)
+    self.monsterT.vectorOfEnums.append(_COLOR.Color.Red)
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertEqual(monster.VectorOfEnums(0), _COLOR.Color.Red)
+    self.assertEqual(monster.VectorOfEnums(1), _COLOR.Color.Blue)
+    self.assertEqual(monster.VectorOfEnums(2), _COLOR.Color.Red)
+
+  def test_empty_vectorofEnums(self):
+    self.monsterT.vectorOfEnums = []
+    monster = self._pack_and_load_buf_class(self.monsterT)
+    self.assertFalse(monster.VectorOfEnumsIsNone())
 
 
 def CheckReadBuffer(buf, offset, sizePrefix=False, file_identifier=None):
-    ''' CheckReadBuffer checks that the given buffer is evaluated correctly
-        as the example Monster. '''
+  """ CheckReadBuffer checks that the given buffer is evaluated correctly
 
-    def asserter(stmt):
-        ''' An assertion helper that is separated from TestCase classes. '''
-        if not stmt:
-            raise AssertionError('CheckReadBuffer case failed')
-    if file_identifier:
-        # test prior to removal of size_prefix
-        asserter(util.GetBufferIdentifier(buf, offset, size_prefixed=sizePrefix) == file_identifier)
-        asserter(util.BufferHasIdentifier(buf, offset, file_identifier=file_identifier, size_prefixed=sizePrefix))
-        asserter(MyGame.Example.Monster.Monster.MonsterBufferHasIdentifier(buf, offset, size_prefixed=sizePrefix))
-    if sizePrefix:
-        size = util.GetSizePrefix(buf, offset)
-        asserter(size == len(buf[offset:])-4)
-        buf, offset = util.RemoveSizePrefix(buf, offset)
-    if file_identifier:
-        asserter(MyGame.Example.Monster.Monster.MonsterBufferHasIdentifier(buf, offset))
-    else:
-        asserter(not MyGame.Example.Monster.Monster.MonsterBufferHasIdentifier(buf, offset))
-    monster = MyGame.Example.Monster.Monster.GetRootAs(buf, offset)
+        as the example Monster.
+  """
 
-    asserter(monster.Hp() == 80)
-    asserter(monster.Mana() == 150)
-    asserter(monster.Name() == b'MyMonster')
+  def asserter(stmt):
+    """ An assertion helper that is separated from TestCase classes. """
+    if not stmt:
+      raise AssertionError('CheckReadBuffer case failed')
 
-    # initialize a Vec3 from Pos()
-    vec = monster.Pos()
-    asserter(vec is not None)
+  if file_identifier:
+    # test prior to removal of size_prefix
+    asserter(
+        util.GetBufferIdentifier(buf, offset, size_prefixed=sizePrefix) ==
+        file_identifier)
+    asserter(
+        util.BufferHasIdentifier(
+            buf,
+            offset,
+            file_identifier=file_identifier,
+            size_prefixed=sizePrefix))
+    asserter(
+        _MONSTER.Monster.MonsterBufferHasIdentifier(
+            buf, offset, size_prefixed=sizePrefix))
+  if sizePrefix:
+    size = util.GetSizePrefix(buf, offset)
+    asserter(size == len(buf[offset:]) - 4)
+    buf, offset = util.RemoveSizePrefix(buf, offset)
+  if file_identifier:
+    asserter(_MONSTER.Monster.MonsterBufferHasIdentifier(buf, offset))
+  else:
+    asserter(not _MONSTER.Monster.MonsterBufferHasIdentifier(buf, offset))
+  monster = _MONSTER.Monster.GetRootAs(buf, offset)
 
-    # verify the properties of the Vec3
-    asserter(vec.X() == 1.0)
-    asserter(vec.Y() == 2.0)
-    asserter(vec.Z() == 3.0)
-    asserter(vec.Test1() == 3.0)
-    asserter(vec.Test2() == 2)
+  asserter(monster.Hp() == 80)
+  asserter(monster.Mana() == 150)
+  asserter(monster.Name() == b'MyMonster')
 
-    # initialize a Test from Test3(...)
-    t = MyGame.Example.Test.Test()
-    t = vec.Test3(t)
-    asserter(t is not None)
+  # initialize a Vec3 from Pos()
+  vec = monster.Pos()
+  asserter(vec is not None)
 
-    # verify the properties of the Test
-    asserter(t.A() == 5)
-    asserter(t.B() == 6)
+  # verify the properties of the Vec3
+  asserter(vec.X() == 1.0)
+  asserter(vec.Y() == 2.0)
+  asserter(vec.Z() == 3.0)
+  asserter(vec.Test1() == 3.0)
+  asserter(vec.Test2() == 2)
 
-    # verify that the enum code matches the enum declaration:
-    union_type = MyGame.Example.Any.Any
-    asserter(monster.TestType() == union_type.Monster)
+  # initialize a Test from Test3(...)
+  t = _TEST.Test()
+  t = vec.Test3(t)
+  asserter(t is not None)
 
-    # initialize a Table from a union field Test(...)
-    table2 = monster.Test()
-    asserter(type(table2) is flatbuffers.table.Table)
+  # verify the properties of the Test
+  asserter(t.A() == 5)
+  asserter(t.B() == 6)
 
-    # initialize a Monster from the Table from the union
-    monster2 = MyGame.Example.Monster.Monster()
-    monster2.Init(table2.Bytes, table2.Pos)
+  # verify that the enum code matches the enum declaration:
+  union_type = _ANY.Any
+  asserter(monster.TestType() == union_type.Monster)
 
-    asserter(monster2.Name() == b"Fred")
+  # initialize a Table from a union field Test(...)
+  table2 = monster.Test()
+  asserter(type(table2) is flatbuffers.table.Table)
 
-    # iterate through the first monster's inventory:
-    asserter(monster.InventoryLength() == 5)
-    asserter(not monster.InventoryIsNone())
+  # initialize a Monster from the Table from the union
+  monster2 = _MONSTER.Monster()
+  monster2.Init(table2.Bytes, table2.Pos)
 
-    invsum = 0
-    for i in compat_range(monster.InventoryLength()):
-        v = monster.Inventory(i)
-        invsum += int(v)
-    asserter(invsum == 10)
+  asserter(monster2.Name() == b'Fred')
 
+  # iterate through the first monster's inventory:
+  asserter(monster.InventoryLength() == 5)
+  asserter(not monster.InventoryIsNone())
+
+  invsum = 0
+  for i in compat_range(monster.InventoryLength()):
+    v = monster.Inventory(i)
+    invsum += int(v)
+  asserter(invsum == 10)
+
+  for i in range(5):
+    asserter(monster.VectorOfLongs(i) == 10**(i * 2))
+
+  asserter(not monster.VectorOfDoublesIsNone())
+  asserter(([-1.7976931348623157e+308, 0, 1.7976931348623157e+308] == [
+      monster.VectorOfDoubles(i) for i in range(monster.VectorOfDoublesLength())
+  ]))
+
+  try:
+    imp.find_module('numpy')
+    # if numpy exists, then we should be able to get the
+    # vector as a numpy array
+    import numpy as np
+
+    asserter(monster.InventoryAsNumpy().sum() == 10)
+    asserter(monster.InventoryAsNumpy().dtype == np.dtype('uint8'))
+
+    VectorOfLongs = monster.VectorOfLongsAsNumpy()
+    asserter(VectorOfLongs.dtype == np.dtype('int64'))
     for i in range(5):
-        asserter(monster.VectorOfLongs(i) == 10 ** (i * 2))
+      asserter(VectorOfLongs[i] == 10**(i * 2))
 
-    asserter(not monster.VectorOfDoublesIsNone())
-    asserter(([-1.7976931348623157e+308, 0, 1.7976931348623157e+308]
-              == [monster.VectorOfDoubles(i)
-                  for i in range(monster.VectorOfDoublesLength())]))
+    VectorOfDoubles = monster.VectorOfDoublesAsNumpy()
+    asserter(VectorOfDoubles.dtype == np.dtype('float64'))
+    asserter(VectorOfDoubles[0] == np.finfo('float64').min)
+    asserter(VectorOfDoubles[1] == 0.0)
+    asserter(VectorOfDoubles[2] == np.finfo('float64').max)
 
-    try:
-        imp.find_module('numpy')
-        # if numpy exists, then we should be able to get the
-        # vector as a numpy array
-        import numpy as np
+  except ImportError:
+    # If numpy does not exist, trying to get vector as numpy
+    # array should raise NumpyRequiredForThisFeature. The way
+    # assertRaises has been implemented prevents us from
+    # asserting this error is raised outside of a test case.
+    pass
 
-        asserter(monster.InventoryAsNumpy().sum() == 10)
-        asserter(monster.InventoryAsNumpy().dtype == np.dtype('uint8'))
+  asserter(monster.Test4Length() == 2)
+  asserter(not monster.Test4IsNone())
 
-        VectorOfLongs = monster.VectorOfLongsAsNumpy()
-        asserter(VectorOfLongs.dtype == np.dtype('int64'))
-        for i in range(5):
-            asserter(VectorOfLongs[i] == 10 ** (i * 2))
+  # create a 'Test' object and populate it:
+  test0 = monster.Test4(0)
+  asserter(type(test0) is _TEST.Test)
 
-        VectorOfDoubles = monster.VectorOfDoublesAsNumpy()
-        asserter(VectorOfDoubles.dtype == np.dtype('float64'))
-        asserter(VectorOfDoubles[0] == np.finfo('float64').min)
-        asserter(VectorOfDoubles[1] == 0.0)
-        asserter(VectorOfDoubles[2] == np.finfo('float64').max)
+  test1 = monster.Test4(1)
+  asserter(type(test1) is _TEST.Test)
 
-    except ImportError:
-        # If numpy does not exist, trying to get vector as numpy
-        # array should raise NumpyRequiredForThisFeature. The way
-        # assertRaises has been implemented prevents us from
-        # asserting this error is raised outside of a test case.
-        pass
+  # the position of test0 and test1 are swapped in monsterdata_java_wire
+  # and monsterdata_test_wire, so ignore ordering
+  v0 = test0.A()
+  v1 = test0.B()
+  v2 = test1.A()
+  v3 = test1.B()
+  sumtest12 = int(v0) + int(v1) + int(v2) + int(v3)
 
-    asserter(monster.Test4Length() == 2)
-    asserter(not monster.Test4IsNone())
+  asserter(sumtest12 == 100)
 
-    # create a 'Test' object and populate it:
-    test0 = monster.Test4(0)
-    asserter(type(test0) is MyGame.Example.Test.Test)
+  asserter(not monster.TestarrayofstringIsNone())
+  asserter(monster.TestarrayofstringLength() == 2)
+  asserter(monster.Testarrayofstring(0) == b'test1')
+  asserter(monster.Testarrayofstring(1) == b'test2')
 
-    test1 = monster.Test4(1)
-    asserter(type(test1) is MyGame.Example.Test.Test)
-
-    # the position of test0 and test1 are swapped in monsterdata_java_wire
-    # and monsterdata_test_wire, so ignore ordering
-    v0 = test0.A()
-    v1 = test0.B()
-    v2 = test1.A()
-    v3 = test1.B()
-    sumtest12 = int(v0) + int(v1) + int(v2) + int(v3)
-
-    asserter(sumtest12 == 100)
-
-    asserter(not monster.TestarrayofstringIsNone())
-    asserter(monster.TestarrayofstringLength() == 2)
-    asserter(monster.Testarrayofstring(0) == b"test1")
-    asserter(monster.Testarrayofstring(1) == b"test2")
-
-    asserter(monster.TestarrayoftablesIsNone())
-    asserter(monster.TestarrayoftablesLength() == 0)
-    asserter(monster.TestnestedflatbufferIsNone())
-    asserter(monster.TestnestedflatbufferLength() == 0)
-    asserter(monster.Testempty() is None)
+  asserter(monster.TestarrayoftablesIsNone())
+  asserter(monster.TestarrayoftablesLength() == 0)
+  asserter(monster.TestnestedflatbufferIsNone())
+  asserter(monster.TestnestedflatbufferLength() == 0)
+  asserter(monster.Testempty() is None)
 
 
 class TestFuzz(unittest.TestCase):
-    ''' Low level stress/fuzz test: serialize/deserialize a variety of
-        different kinds of data in different combinations '''
+  """ Low level stress/fuzz test: serialize/deserialize a variety of
 
-    binary_type = compat.binary_types[0] # this will always exist
-    ofInt32Bytes = binary_type([0x83, 0x33, 0x33, 0x33])
-    ofInt64Bytes = binary_type([0x84, 0x44, 0x44, 0x44,
-                                0x44, 0x44, 0x44, 0x44])
-    overflowingInt32Val = flatbuffers.encode.Get(flatbuffers.packer.int32,
-                                                 ofInt32Bytes, 0)
-    overflowingInt64Val = flatbuffers.encode.Get(flatbuffers.packer.int64,
-                                                 ofInt64Bytes, 0)
+        different kinds of data in different combinations
+  """
 
-    # Values we're testing against: chosen to ensure no bits get chopped
-    # off anywhere, and also be different from eachother.
-    boolVal = True
-    int8Val = N.Int8Flags.py_type(-127) # 0x81
-    uint8Val = N.Uint8Flags.py_type(0xFF)
-    int16Val = N.Int16Flags.py_type(-32222) # 0x8222
-    uint16Val = N.Uint16Flags.py_type(0xFEEE)
-    int32Val = N.Int32Flags.py_type(overflowingInt32Val)
-    uint32Val = N.Uint32Flags.py_type(0xFDDDDDDD)
-    int64Val = N.Int64Flags.py_type(overflowingInt64Val)
-    uint64Val = N.Uint64Flags.py_type(0xFCCCCCCCCCCCCCCC)
-    # Python uses doubles, so force it here
-    float32Val = N.Float32Flags.py_type(ctypes.c_float(3.14159).value)
-    float64Val = N.Float64Flags.py_type(3.14159265359)
+  binary_type = compat.binary_types[0]  # this will always exist
+  ofInt32Bytes = binary_type([0x83, 0x33, 0x33, 0x33])
+  ofInt64Bytes = binary_type([0x84, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44])
+  overflowingInt32Val = flatbuffers.encode.Get(flatbuffers.packer.int32,
+                                               ofInt32Bytes, 0)
+  overflowingInt64Val = flatbuffers.encode.Get(flatbuffers.packer.int64,
+                                               ofInt64Bytes, 0)
 
-    def test_fuzz(self):
-        return self.check_once(11, 100)
+  # Values we're testing against: chosen to ensure no bits get chopped
+  # off anywhere, and also be different from eachother.
+  boolVal = True
+  int8Val = N.Int8Flags.py_type(-127)  # 0x81
+  uint8Val = N.Uint8Flags.py_type(0xFF)
+  int16Val = N.Int16Flags.py_type(-32222)  # 0x8222
+  uint16Val = N.Uint16Flags.py_type(0xFEEE)
+  int32Val = N.Int32Flags.py_type(overflowingInt32Val)
+  uint32Val = N.Uint32Flags.py_type(0xFDDDDDDD)
+  int64Val = N.Int64Flags.py_type(overflowingInt64Val)
+  uint64Val = N.Uint64Flags.py_type(0xFCCCCCCCCCCCCCCC)
+  # Python uses doubles, so force it here
+  float32Val = N.Float32Flags.py_type(ctypes.c_float(3.14159).value)
+  float64Val = N.Float64Flags.py_type(3.14159265359)
 
-    def check_once(self, fuzzFields, fuzzObjects):
-        testValuesMax = 11 # hardcoded to the number of scalar types
+  def test_fuzz(self):
+    return self.check_once(11, 100)
 
-        builder = flatbuffers.Builder(0)
-        l = LCG()
+  def check_once(self, fuzzFields, fuzzObjects):
+    testValuesMax = 11  # hardcoded to the number of scalar types
 
-        objects = [0 for _ in compat_range(fuzzObjects)]
+    builder = flatbuffers.Builder(0)
+    l = LCG()
 
-        # Generate fuzzObjects random objects each consisting of
-        # fuzzFields fields, each of a random type.
-        for i in compat_range(fuzzObjects):
-            builder.StartObject(fuzzFields)
+    objects = [0 for _ in compat_range(fuzzObjects)]
 
-            for j in compat_range(fuzzFields):
-                choice = int(l.Next()) % testValuesMax
-                if choice == 0:
-                    builder.PrependBoolSlot(int(j), self.boolVal, False)
-                elif choice == 1:
-                    builder.PrependInt8Slot(int(j), self.int8Val, 0)
-                elif choice == 2:
-                    builder.PrependUint8Slot(int(j), self.uint8Val, 0)
-                elif choice == 3:
-                    builder.PrependInt16Slot(int(j), self.int16Val, 0)
-                elif choice == 4:
-                    builder.PrependUint16Slot(int(j), self.uint16Val, 0)
-                elif choice == 5:
-                    builder.PrependInt32Slot(int(j), self.int32Val, 0)
-                elif choice == 6:
-                    builder.PrependUint32Slot(int(j), self.uint32Val, 0)
-                elif choice == 7:
-                    builder.PrependInt64Slot(int(j), self.int64Val, 0)
-                elif choice == 8:
-                    builder.PrependUint64Slot(int(j), self.uint64Val, 0)
-                elif choice == 9:
-                    builder.PrependFloat32Slot(int(j), self.float32Val, 0)
-                elif choice == 10:
-                    builder.PrependFloat64Slot(int(j), self.float64Val, 0)
-                else:
-                    raise RuntimeError('unreachable')
+    # Generate fuzzObjects random objects each consisting of
+    # fuzzFields fields, each of a random type.
+    for i in compat_range(fuzzObjects):
+      builder.StartObject(fuzzFields)
 
-            off = builder.EndObject()
+      for j in compat_range(fuzzFields):
+        choice = int(l.Next()) % testValuesMax
+        if choice == 0:
+          builder.PrependBoolSlot(int(j), self.boolVal, False)
+        elif choice == 1:
+          builder.PrependInt8Slot(int(j), self.int8Val, 0)
+        elif choice == 2:
+          builder.PrependUint8Slot(int(j), self.uint8Val, 0)
+        elif choice == 3:
+          builder.PrependInt16Slot(int(j), self.int16Val, 0)
+        elif choice == 4:
+          builder.PrependUint16Slot(int(j), self.uint16Val, 0)
+        elif choice == 5:
+          builder.PrependInt32Slot(int(j), self.int32Val, 0)
+        elif choice == 6:
+          builder.PrependUint32Slot(int(j), self.uint32Val, 0)
+        elif choice == 7:
+          builder.PrependInt64Slot(int(j), self.int64Val, 0)
+        elif choice == 8:
+          builder.PrependUint64Slot(int(j), self.uint64Val, 0)
+        elif choice == 9:
+          builder.PrependFloat32Slot(int(j), self.float32Val, 0)
+        elif choice == 10:
+          builder.PrependFloat64Slot(int(j), self.float64Val, 0)
+        else:
+          raise RuntimeError('unreachable')
 
-            # store the offset from the end of the builder buffer,
-            # since it will keep growing:
-            objects[i] = off
+      off = builder.EndObject()
 
-        # Do some bookkeeping to generate stats on fuzzes:
-        stats = defaultdict(int)
-        def check(table, desc, want, got):
-            stats[desc] += 1
-            self.assertEqual(want, got, "%s != %s, %s" % (want, got, desc))
+      # store the offset from the end of the builder buffer,
+      # since it will keep growing:
+      objects[i] = off
 
-        l = LCG()  # Reset.
+    # Do some bookkeeping to generate stats on fuzzes:
+    stats = defaultdict(int)
 
-        # Test that all objects we generated are readable and return the
-        # expected values. We generate random objects in the same order
-        # so this is deterministic.
-        for i in compat_range(fuzzObjects):
+    def check(table, desc, want, got):
+      stats[desc] += 1
+      self.assertEqual(want, got, '%s != %s, %s' % (want, got, desc))
 
-            table = flatbuffers.table.Table(builder.Bytes,
-                                            len(builder.Bytes) - objects[i])
+    l = LCG()  # Reset.
 
-            for j in compat_range(fuzzFields):
-                field_count = flatbuffers.builder.VtableMetadataFields + j
-                f = N.VOffsetTFlags.py_type(field_count *
-                                            N.VOffsetTFlags.bytewidth)
-                choice = int(l.Next()) % testValuesMax
+    # Test that all objects we generated are readable and return the
+    # expected values. We generate random objects in the same order
+    # so this is deterministic.
+    for i in compat_range(fuzzObjects):
 
-                if choice == 0:
-                    check(table, "bool", self.boolVal,
-                          table.GetSlot(f, False, N.BoolFlags))
-                elif choice == 1:
-                    check(table, "int8", self.int8Val,
-                          table.GetSlot(f, 0, N.Int8Flags))
-                elif choice == 2:
-                    check(table, "uint8", self.uint8Val,
-                          table.GetSlot(f, 0, N.Uint8Flags))
-                elif choice == 3:
-                    check(table, "int16", self.int16Val,
-                          table.GetSlot(f, 0, N.Int16Flags))
-                elif choice == 4:
-                    check(table, "uint16", self.uint16Val,
-                          table.GetSlot(f, 0, N.Uint16Flags))
-                elif choice == 5:
-                    check(table, "int32", self.int32Val,
-                          table.GetSlot(f, 0, N.Int32Flags))
-                elif choice == 6:
-                    check(table, "uint32", self.uint32Val,
-                          table.GetSlot(f, 0, N.Uint32Flags))
-                elif choice == 7:
-                    check(table, "int64", self.int64Val,
-                          table.GetSlot(f, 0, N.Int64Flags))
-                elif choice == 8:
-                    check(table, "uint64", self.uint64Val,
-                          table.GetSlot(f, 0, N.Uint64Flags))
-                elif choice == 9:
-                    check(table, "float32", self.float32Val,
-                          table.GetSlot(f, 0, N.Float32Flags))
-                elif choice == 10:
-                    check(table, "float64", self.float64Val,
-                          table.GetSlot(f, 0, N.Float64Flags))
-                else:
-                    raise RuntimeError('unreachable')
+      table = flatbuffers.table.Table(builder.Bytes,
+                                      len(builder.Bytes) - objects[i])
 
-        # If enough checks were made, verify that all scalar types were used:
-        self.assertEqual(testValuesMax, len(stats),
-                "fuzzing failed to test all scalar types: %s" % stats)
+      for j in compat_range(fuzzFields):
+        field_count = flatbuffers.builder.VtableMetadataFields + j
+        f = N.VOffsetTFlags.py_type(field_count * N.VOffsetTFlags.bytewidth)
+        choice = int(l.Next()) % testValuesMax
+
+        if choice == 0:
+          check(table, 'bool', self.boolVal,
+                table.GetSlot(f, False, N.BoolFlags))
+        elif choice == 1:
+          check(table, 'int8', self.int8Val, table.GetSlot(f, 0, N.Int8Flags))
+        elif choice == 2:
+          check(table, 'uint8', self.uint8Val,
+                table.GetSlot(f, 0, N.Uint8Flags))
+        elif choice == 3:
+          check(table, 'int16', self.int16Val,
+                table.GetSlot(f, 0, N.Int16Flags))
+        elif choice == 4:
+          check(table, 'uint16', self.uint16Val,
+                table.GetSlot(f, 0, N.Uint16Flags))
+        elif choice == 5:
+          check(table, 'int32', self.int32Val,
+                table.GetSlot(f, 0, N.Int32Flags))
+        elif choice == 6:
+          check(table, 'uint32', self.uint32Val,
+                table.GetSlot(f, 0, N.Uint32Flags))
+        elif choice == 7:
+          check(table, 'int64', self.int64Val,
+                table.GetSlot(f, 0, N.Int64Flags))
+        elif choice == 8:
+          check(table, 'uint64', self.uint64Val,
+                table.GetSlot(f, 0, N.Uint64Flags))
+        elif choice == 9:
+          check(table, 'float32', self.float32Val,
+                table.GetSlot(f, 0, N.Float32Flags))
+        elif choice == 10:
+          check(table, 'float64', self.float64Val,
+                table.GetSlot(f, 0, N.Float64Flags))
+        else:
+          raise RuntimeError('unreachable')
+
+    # If enough checks were made, verify that all scalar types were used:
+    self.assertEqual(testValuesMax, len(stats),
+                     'fuzzing failed to test all scalar types: %s' % stats)
 
 
 class TestByteLayout(unittest.TestCase):
-    ''' TestByteLayout checks the bytes of a Builder in various scenarios. '''
+  """ TestByteLayout checks the bytes of a Builder in various scenarios. """
 
-    def assertBuilderEquals(self, builder, want_chars_or_ints):
-        def integerize(x):
-            if isinstance(x, compat.string_types):
-                return ord(x)
-            return x
+  def assertBuilderEquals(self, builder, want_chars_or_ints):
 
-        want_ints = list(map(integerize, want_chars_or_ints))
-        want = bytearray(want_ints)
-        got = builder.Bytes[builder.Head():] # use the buffer directly
-        self.assertEqual(want, got)
+    def integerize(x):
+      if isinstance(x, compat.string_types):
+        return ord(x)
+      return x
 
-    def test_numbers(self):
-        b = flatbuffers.Builder(0)
-        self.assertBuilderEquals(b, [])
-        b.PrependBool(True)
-        self.assertBuilderEquals(b, [1])
-        b.PrependInt8(-127)
-        self.assertBuilderEquals(b, [129, 1])
-        b.PrependUint8(255)
-        self.assertBuilderEquals(b, [255, 129, 1])
-        b.PrependInt16(-32222)
-        self.assertBuilderEquals(b, [0x22, 0x82, 0, 255, 129, 1]) # first pad
-        b.PrependUint16(0xFEEE)
-        # no pad this time:
-        self.assertBuilderEquals(b, [0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1])
-        b.PrependInt32(-53687092)
-        self.assertBuilderEquals(b, [204, 204, 204, 252, 0xEE, 0xFE,
-                                     0x22, 0x82, 0, 255, 129, 1])
-        b.PrependUint32(0x98765432)
-        self.assertBuilderEquals(b, [0x32, 0x54, 0x76, 0x98,
-                                     204, 204, 204, 252,
-                                     0xEE, 0xFE, 0x22, 0x82,
-                                     0, 255, 129, 1])
+    want_ints = list(map(integerize, want_chars_or_ints))
+    want = bytearray(want_ints)
+    got = builder.Bytes[builder.Head():]  # use the buffer directly
+    self.assertEqual(want, got)
 
-    def test_numbers64(self):
-        b = flatbuffers.Builder(0)
-        b.PrependUint64(0x1122334455667788)
-        self.assertBuilderEquals(b, [0x88, 0x77, 0x66, 0x55,
-                                     0x44, 0x33, 0x22, 0x11])
+  def test_numbers(self):
+    b = flatbuffers.Builder(0)
+    self.assertBuilderEquals(b, [])
+    b.PrependBool(True)
+    self.assertBuilderEquals(b, [1])
+    b.PrependInt8(-127)
+    self.assertBuilderEquals(b, [129, 1])
+    b.PrependUint8(255)
+    self.assertBuilderEquals(b, [255, 129, 1])
+    b.PrependInt16(-32222)
+    self.assertBuilderEquals(b, [0x22, 0x82, 0, 255, 129, 1])  # first pad
+    b.PrependUint16(0xFEEE)
+    # no pad this time:
+    self.assertBuilderEquals(b, [0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1])
+    b.PrependInt32(-53687092)
+    self.assertBuilderEquals(
+        b, [204, 204, 204, 252, 0xEE, 0xFE, 0x22, 0x82, 0, 255, 129, 1])
+    b.PrependUint32(0x98765432)
+    self.assertBuilderEquals(b, [
+        0x32, 0x54, 0x76, 0x98, 204, 204, 204, 252, 0xEE, 0xFE, 0x22, 0x82, 0,
+        255, 129, 1
+    ])
 
-        b = flatbuffers.Builder(0)
-        b.PrependInt64(0x1122334455667788)
-        self.assertBuilderEquals(b, [0x88, 0x77, 0x66, 0x55,
-                                     0x44, 0x33, 0x22, 0x11])
+  def test_numbers64(self):
+    b = flatbuffers.Builder(0)
+    b.PrependUint64(0x1122334455667788)
+    self.assertBuilderEquals(b,
+                             [0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11])
 
-    def test_1xbyte_vector(self):
-        b = flatbuffers.Builder(0)
-        self.assertBuilderEquals(b, [])
-        b.StartVector(flatbuffers.number_types.Uint8Flags.bytewidth, 1, 1)
-        self.assertBuilderEquals(b, [0, 0, 0]) # align to 4bytes
-        b.PrependByte(1)
-        self.assertBuilderEquals(b, [1, 0, 0, 0])
-        b.EndVector()
-        self.assertBuilderEquals(b, [1, 0, 0, 0, 1, 0, 0, 0]) # padding
+    b = flatbuffers.Builder(0)
+    b.PrependInt64(0x1122334455667788)
+    self.assertBuilderEquals(b,
+                             [0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11])
 
-    def test_2xbyte_vector(self):
-        b = flatbuffers.Builder(0)
-        b.StartVector(flatbuffers.number_types.Uint8Flags.bytewidth, 2, 1)
-        self.assertBuilderEquals(b, [0, 0]) # align to 4bytes
-        b.PrependByte(1)
-        self.assertBuilderEquals(b, [1, 0, 0])
-        b.PrependByte(2)
-        self.assertBuilderEquals(b, [2, 1, 0, 0])
-        b.EndVector()
-        self.assertBuilderEquals(b, [2, 0, 0, 0, 2, 1, 0, 0]) # padding
+  def test_1xbyte_vector(self):
+    b = flatbuffers.Builder(0)
+    self.assertBuilderEquals(b, [])
+    b.StartVector(flatbuffers.number_types.Uint8Flags.bytewidth, 1, 1)
+    self.assertBuilderEquals(b, [0, 0, 0])  # align to 4bytes
+    b.PrependByte(1)
+    self.assertBuilderEquals(b, [1, 0, 0, 0])
+    b.EndVector()
+    self.assertBuilderEquals(b, [1, 0, 0, 0, 1, 0, 0, 0])  # padding
 
-    def test_1xuint16_vector(self):
-        b = flatbuffers.Builder(0)
-        b.StartVector(flatbuffers.number_types.Uint16Flags.bytewidth, 1, 1)
-        self.assertBuilderEquals(b, [0, 0]) # align to 4bytes
-        b.PrependUint16(1)
-        self.assertBuilderEquals(b, [1, 0, 0, 0])
-        b.EndVector()
-        self.assertBuilderEquals(b, [1, 0, 0, 0, 1, 0, 0, 0]) # padding
+  def test_2xbyte_vector(self):
+    b = flatbuffers.Builder(0)
+    b.StartVector(flatbuffers.number_types.Uint8Flags.bytewidth, 2, 1)
+    self.assertBuilderEquals(b, [0, 0])  # align to 4bytes
+    b.PrependByte(1)
+    self.assertBuilderEquals(b, [1, 0, 0])
+    b.PrependByte(2)
+    self.assertBuilderEquals(b, [2, 1, 0, 0])
+    b.EndVector()
+    self.assertBuilderEquals(b, [2, 0, 0, 0, 2, 1, 0, 0])  # padding
 
-    def test_2xuint16_vector(self):
-        b = flatbuffers.Builder(0)
-        b.StartVector(flatbuffers.number_types.Uint16Flags.bytewidth, 2, 1)
-        self.assertBuilderEquals(b, []) # align to 4bytes
-        b.PrependUint16(0xABCD)
-        self.assertBuilderEquals(b, [0xCD, 0xAB])
-        b.PrependUint16(0xDCBA)
-        self.assertBuilderEquals(b, [0xBA, 0xDC, 0xCD, 0xAB])
-        b.EndVector()
-        self.assertBuilderEquals(b, [2, 0, 0, 0, 0xBA, 0xDC, 0xCD, 0xAB])
+  def test_1xuint16_vector(self):
+    b = flatbuffers.Builder(0)
+    b.StartVector(flatbuffers.number_types.Uint16Flags.bytewidth, 1, 1)
+    self.assertBuilderEquals(b, [0, 0])  # align to 4bytes
+    b.PrependUint16(1)
+    self.assertBuilderEquals(b, [1, 0, 0, 0])
+    b.EndVector()
+    self.assertBuilderEquals(b, [1, 0, 0, 0, 1, 0, 0, 0])  # padding
 
-    def test_create_ascii_string(self):
-        b = flatbuffers.Builder(0)
-        b.CreateString(u"foo", encoding='ascii')
+  def test_2xuint16_vector(self):
+    b = flatbuffers.Builder(0)
+    b.StartVector(flatbuffers.number_types.Uint16Flags.bytewidth, 2, 1)
+    self.assertBuilderEquals(b, [])  # align to 4bytes
+    b.PrependUint16(0xABCD)
+    self.assertBuilderEquals(b, [0xCD, 0xAB])
+    b.PrependUint16(0xDCBA)
+    self.assertBuilderEquals(b, [0xBA, 0xDC, 0xCD, 0xAB])
+    b.EndVector()
+    self.assertBuilderEquals(b, [2, 0, 0, 0, 0xBA, 0xDC, 0xCD, 0xAB])
 
-        # 0-terminated, no pad:
-        self.assertBuilderEquals(b, [3, 0, 0, 0, 'f', 'o', 'o', 0])
-        b.CreateString(u"moop", encoding='ascii')
-        # 0-terminated, 3-byte pad:
-        self.assertBuilderEquals(b, [4, 0, 0, 0, 'm', 'o', 'o', 'p',
-                                     0, 0, 0, 0,
-                                     3, 0, 0, 0, 'f', 'o', 'o', 0])
+  def test_create_ascii_string(self):
+    b = flatbuffers.Builder(0)
+    b.CreateString(u'foo', encoding='ascii')
 
-    def test_create_utf8_string(self):
-        b = flatbuffers.Builder(0)
-        b.CreateString(u"Цлїςσδε")
-        self.assertBuilderEquals(b, "\x0e\x00\x00\x00\xd0\xa6\xd0\xbb\xd1\x97" \
-            "\xcf\x82\xcf\x83\xce\xb4\xce\xb5\x00\x00")
+    # 0-terminated, no pad:
+    self.assertBuilderEquals(b, [3, 0, 0, 0, 'f', 'o', 'o', 0])
+    b.CreateString(u'moop', encoding='ascii')
+    # 0-terminated, 3-byte pad:
+    self.assertBuilderEquals(b, [
+        4, 0, 0, 0, 'm', 'o', 'o', 'p', 0, 0, 0, 0, 3, 0, 0, 0, 'f', 'o', 'o', 0
+    ])
 
-        b.CreateString(u"ﾌﾑｱﾑｶﾓｹﾓ")
-        self.assertBuilderEquals(b, "\x18\x00\x00\x00\xef\xbe\x8c\xef\xbe\x91" \
-            "\xef\xbd\xb1\xef\xbe\x91\xef\xbd\xb6\xef\xbe\x93\xef\xbd\xb9\xef" \
-            "\xbe\x93\x00\x00\x00\x00\x0e\x00\x00\x00\xd0\xa6\xd0\xbb\xd1\x97" \
-            "\xcf\x82\xcf\x83\xce\xb4\xce\xb5\x00\x00")
+  def test_create_utf8_string(self):
+    b = flatbuffers.Builder(0)
+    b.CreateString(u'Цлїςσδε')
+    self.assertBuilderEquals(b, '\x0e\x00\x00\x00\xd0\xa6\xd0\xbb\xd1\x97' \
+        '\xcf\x82\xcf\x83\xce\xb4\xce\xb5\x00\x00')
 
-    def test_create_arbitrary_string(self):
-        b = flatbuffers.Builder(0)
-        s = "\x01\x02\x03"
-        b.CreateString(s) # Default encoding is utf-8.
-        # 0-terminated, no pad:
-        self.assertBuilderEquals(b, [3, 0, 0, 0, 1, 2, 3, 0])
-        s2 = "\x04\x05\x06\x07"
-        b.CreateString(s2) # Default encoding is utf-8.
-        # 0-terminated, 3-byte pad:
-        self.assertBuilderEquals(b, [4, 0, 0, 0, 4, 5, 6, 7, 0, 0, 0, 0,
-                                     3, 0, 0, 0, 1, 2, 3, 0])
+    b.CreateString(u'ﾌﾑｱﾑｶﾓｹﾓ')
+    self.assertBuilderEquals(b, '\x18\x00\x00\x00\xef\xbe\x8c\xef\xbe\x91' \
+        '\xef\xbd\xb1\xef\xbe\x91\xef\xbd\xb6\xef\xbe\x93\xef\xbd\xb9\xef' \
+        '\xbe\x93\x00\x00\x00\x00\x0e\x00\x00\x00\xd0\xa6\xd0\xbb\xd1\x97' \
+        '\xcf\x82\xcf\x83\xce\xb4\xce\xb5\x00\x00')
 
-    def test_create_byte_vector(self):
-        b = flatbuffers.Builder(0)
-        b.CreateByteVector(b"")
-        # 0-byte pad:
-        self.assertBuilderEquals(b, [0, 0, 0, 0])
+  def test_create_arbitrary_string(self):
+    b = flatbuffers.Builder(0)
+    s = '\x01\x02\x03'
+    b.CreateString(s)  # Default encoding is utf-8.
+    # 0-terminated, no pad:
+    self.assertBuilderEquals(b, [3, 0, 0, 0, 1, 2, 3, 0])
+    s2 = '\x04\x05\x06\x07'
+    b.CreateString(s2)  # Default encoding is utf-8.
+    # 0-terminated, 3-byte pad:
+    self.assertBuilderEquals(
+        b, [4, 0, 0, 0, 4, 5, 6, 7, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3, 0])
 
-        b = flatbuffers.Builder(0)
-        b.CreateByteVector(b"\x01\x02\x03")
-        # 1-byte pad:
-        self.assertBuilderEquals(b, [3, 0, 0, 0, 1, 2, 3, 0])
+  def test_create_byte_vector(self):
+    b = flatbuffers.Builder(0)
+    b.CreateByteVector(b'')
+    # 0-byte pad:
+    self.assertBuilderEquals(b, [0, 0, 0, 0])
 
-    def test_create_numpy_vector_int8(self):
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            import numpy as np
+    b = flatbuffers.Builder(0)
+    b.CreateByteVector(b'\x01\x02\x03')
+    # 1-byte pad:
+    self.assertBuilderEquals(b, [3, 0, 0, 0, 1, 2, 3, 0])
 
-            # Systems endian:
-            b = flatbuffers.Builder(0)
-            x = np.array([1, 2, -3], dtype=np.int8)
-            b.CreateNumpyVector(x)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,  # vector length
-                1, 2, 256 - 3, 0   # vector value + padding
-            ])
+  def test_create_numpy_vector_int8(self):
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      import numpy as np
 
-            # Reverse endian:
-            b = flatbuffers.Builder(0)
-            x_other_endian = x.byteswap().newbyteorder()
-            b.CreateNumpyVector(x_other_endian)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,  # vector length
-                1, 2, 256 - 3, 0   # vector value + padding
-            ])
-        except ImportError:
-            b = flatbuffers.Builder(0)
-            x = 0
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                NumpyRequiredForThisFeature)
+      # Systems endian:
+      b = flatbuffers.Builder(0)
+      x = np.array([1, 2, -3], dtype=np.int8)
+      b.CreateNumpyVector(x)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              1,
+              2,
+              256 - 3,
+              0  # vector value + padding
+          ])
 
-    def test_create_numpy_vector_uint16(self):
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            import numpy as np
+      # Reverse endian:
+      b = flatbuffers.Builder(0)
+      x_other_endian = x.byteswap().newbyteorder()
+      b.CreateNumpyVector(x_other_endian)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              1,
+              2,
+              256 - 3,
+              0  # vector value + padding
+          ])
+    except ImportError:
+      b = flatbuffers.Builder(0)
+      x = 0
+      assertRaises(self, lambda: b.CreateNumpyVector(x),
+                   NumpyRequiredForThisFeature)
 
-            # Systems endian:
-            b = flatbuffers.Builder(0)
-            x = np.array([1, 2, 312], dtype=np.uint16)
-            b.CreateNumpyVector(x)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,     # vector length
-                1, 0,           # 1
-                2, 0,           # 2
-                312 - 256, 1,   # 312
-                0, 0            # padding
-            ])
+  def test_create_numpy_vector_uint16(self):
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      import numpy as np
 
-            # Reverse endian:
-            b = flatbuffers.Builder(0)
-            x_other_endian = x.byteswap().newbyteorder()
-            b.CreateNumpyVector(x_other_endian)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,     # vector length
-                1, 0,           # 1
-                2, 0,           # 2
-                312 - 256, 1,   # 312
-                0, 0            # padding
-            ])
-        except ImportError:
-            b = flatbuffers.Builder(0)
-            x = 0
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                NumpyRequiredForThisFeature)
+      # Systems endian:
+      b = flatbuffers.Builder(0)
+      x = np.array([1, 2, 312], dtype=np.uint16)
+      b.CreateNumpyVector(x)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              1,
+              0,  # 1
+              2,
+              0,  # 2
+              312 - 256,
+              1,  # 312
+              0,
+              0  # padding
+          ])
 
-    def test_create_numpy_vector_int64(self):
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            import numpy as np
+      # Reverse endian:
+      b = flatbuffers.Builder(0)
+      x_other_endian = x.byteswap().newbyteorder()
+      b.CreateNumpyVector(x_other_endian)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              1,
+              0,  # 1
+              2,
+              0,  # 2
+              312 - 256,
+              1,  # 312
+              0,
+              0  # padding
+          ])
+    except ImportError:
+      b = flatbuffers.Builder(0)
+      x = 0
+      assertRaises(self, lambda: b.CreateNumpyVector(x),
+                   NumpyRequiredForThisFeature)
 
-            # Systems endian:
-            b = flatbuffers.Builder(0)
-            x = np.array([1, 2, -12], dtype=np.int64)
-            b.CreateNumpyVector(x)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,                     # vector length
-                1, 0, 0, 0, 0, 0, 0, 0,         # 1
-                2, 0, 0, 0, 0, 0, 0, 0,         # 2
-                256 - 12, 255, 255, 255, 255, 255, 255, 255   # -12
-            ])
+  def test_create_numpy_vector_int64(self):
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      import numpy as np
 
-            # Reverse endian:
-            b = flatbuffers.Builder(0)
-            x_other_endian = x.byteswap().newbyteorder()
-            b.CreateNumpyVector(x_other_endian)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,                     # vector length
-                1, 0, 0, 0, 0, 0, 0, 0,         # 1
-                2, 0, 0, 0, 0, 0, 0, 0,         # 2
-                256 - 12, 255, 255, 255, 255, 255, 255, 255   # -12
-            ])
+      # Systems endian:
+      b = flatbuffers.Builder(0)
+      x = np.array([1, 2, -12], dtype=np.int64)
+      b.CreateNumpyVector(x)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              1,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,  # 1
+              2,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,  # 2
+              256 - 12,
+              255,
+              255,
+              255,
+              255,
+              255,
+              255,
+              255  # -12
+          ])
 
-        except ImportError:
-            b = flatbuffers.Builder(0)
-            x = 0
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                NumpyRequiredForThisFeature)
+      # Reverse endian:
+      b = flatbuffers.Builder(0)
+      x_other_endian = x.byteswap().newbyteorder()
+      b.CreateNumpyVector(x_other_endian)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              1,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,  # 1
+              2,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,  # 2
+              256 - 12,
+              255,
+              255,
+              255,
+              255,
+              255,
+              255,
+              255  # -12
+          ])
 
-    def test_create_numpy_vector_float32(self):
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            import numpy as np
+    except ImportError:
+      b = flatbuffers.Builder(0)
+      x = 0
+      assertRaises(self, lambda: b.CreateNumpyVector(x),
+                   NumpyRequiredForThisFeature)
 
-            # Systems endian:
-            b = flatbuffers.Builder(0)
-            x = np.array([1, 2, -12], dtype=np.float32)
-            b.CreateNumpyVector(x)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,                     # vector length
-                0, 0, 128, 63,                  # 1
-                0, 0, 0, 64,                    # 2
-                0, 0, 64, 193                   # -12
-            ])
+  def test_create_numpy_vector_float32(self):
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      import numpy as np
 
-            # Reverse endian:
-            b = flatbuffers.Builder(0)
-            x_other_endian = x.byteswap().newbyteorder()
-            b.CreateNumpyVector(x_other_endian)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,                     # vector length
-                0, 0, 128, 63,                  # 1
-                0, 0, 0, 64,                    # 2
-                0, 0, 64, 193                   # -12
-            ])
+      # Systems endian:
+      b = flatbuffers.Builder(0)
+      x = np.array([1, 2, -12], dtype=np.float32)
+      b.CreateNumpyVector(x)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              0,
+              0,
+              128,
+              63,  # 1
+              0,
+              0,
+              0,
+              64,  # 2
+              0,
+              0,
+              64,
+              193  # -12
+          ])
 
-        except ImportError:
-            b = flatbuffers.Builder(0)
-            x = 0
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                NumpyRequiredForThisFeature)
+      # Reverse endian:
+      b = flatbuffers.Builder(0)
+      x_other_endian = x.byteswap().newbyteorder()
+      b.CreateNumpyVector(x_other_endian)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              0,
+              0,
+              128,
+              63,  # 1
+              0,
+              0,
+              0,
+              64,  # 2
+              0,
+              0,
+              64,
+              193  # -12
+          ])
 
-    def test_create_numpy_vector_float64(self):
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            import numpy as np
+    except ImportError:
+      b = flatbuffers.Builder(0)
+      x = 0
+      assertRaises(self, lambda: b.CreateNumpyVector(x),
+                   NumpyRequiredForThisFeature)
 
-            # Systems endian:
-            b = flatbuffers.Builder(0)
-            x = np.array([1, 2, -12], dtype=np.float64)
-            b.CreateNumpyVector(x)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,                     # vector length
-                0, 0, 0, 0, 0, 0, 240, 63,                  # 1
-                0, 0, 0, 0, 0, 0, 0, 64,                    # 2
-                0, 0, 0, 0, 0, 0, 40, 192                   # -12
-            ])
+  def test_create_numpy_vector_float64(self):
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      import numpy as np
 
-            # Reverse endian:
-            b = flatbuffers.Builder(0)
-            x_other_endian = x.byteswap().newbyteorder()
-            b.CreateNumpyVector(x_other_endian)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0,                     # vector length
-                0, 0, 0, 0, 0, 0, 240, 63,                  # 1
-                0, 0, 0, 0, 0, 0, 0, 64,                    # 2
-                0, 0, 0, 0, 0, 0, 40, 192                   # -12
-            ])
+      # Systems endian:
+      b = flatbuffers.Builder(0)
+      x = np.array([1, 2, -12], dtype=np.float64)
+      b.CreateNumpyVector(x)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              240,
+              63,  # 1
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              64,  # 2
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              40,
+              192  # -12
+          ])
 
-        except ImportError:
-            b = flatbuffers.Builder(0)
-            x = 0
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                NumpyRequiredForThisFeature)
+      # Reverse endian:
+      b = flatbuffers.Builder(0)
+      x_other_endian = x.byteswap().newbyteorder()
+      b.CreateNumpyVector(x_other_endian)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              240,
+              63,  # 1
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              64,  # 2
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              40,
+              192  # -12
+          ])
 
-    def test_create_numpy_vector_bool(self):
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            import numpy as np
+    except ImportError:
+      b = flatbuffers.Builder(0)
+      x = 0
+      assertRaises(self, lambda: b.CreateNumpyVector(x),
+                   NumpyRequiredForThisFeature)
 
-            # Systems endian:
-            b = flatbuffers.Builder(0)
-            x = np.array([True, False, True], dtype=np.bool)
-            b.CreateNumpyVector(x)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0, # vector length
-                1, 0, 1, 0  # vector values + padding
-            ])
+  def test_create_numpy_vector_bool(self):
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      import numpy as np
 
-            # Reverse endian:
-            b = flatbuffers.Builder(0)
-            x_other_endian = x.byteswap().newbyteorder()
-            b.CreateNumpyVector(x_other_endian)
-            self.assertBuilderEquals(b, [
-                3, 0, 0, 0, # vector length
-                1, 0, 1, 0  # vector values + padding
-            ])
+      # Systems endian:
+      b = flatbuffers.Builder(0)
+      x = np.array([True, False, True], dtype=np.bool)
+      b.CreateNumpyVector(x)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              1,
+              0,
+              1,
+              0  # vector values + padding
+          ])
 
-        except ImportError:
-            b = flatbuffers.Builder(0)
-            x = 0
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                NumpyRequiredForThisFeature)
+      # Reverse endian:
+      b = flatbuffers.Builder(0)
+      x_other_endian = x.byteswap().newbyteorder()
+      b.CreateNumpyVector(x_other_endian)
+      self.assertBuilderEquals(
+          b,
+          [
+              3,
+              0,
+              0,
+              0,  # vector length
+              1,
+              0,
+              1,
+              0  # vector values + padding
+          ])
 
-    def test_create_numpy_vector_reject_strings(self):
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            import numpy as np
+    except ImportError:
+      b = flatbuffers.Builder(0)
+      x = 0
+      assertRaises(self, lambda: b.CreateNumpyVector(x),
+                   NumpyRequiredForThisFeature)
 
-            # Create String array
-            b = flatbuffers.Builder(0)
-            x = np.array(["hello", "fb", "testing"])
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                TypeError)
+  def test_create_numpy_vector_reject_strings(self):
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      import numpy as np
 
-        except ImportError:
-            b = flatbuffers.Builder(0)
-            x = 0
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                NumpyRequiredForThisFeature)
+      # Create String array
+      b = flatbuffers.Builder(0)
+      x = np.array(['hello', 'fb', 'testing'])
+      assertRaises(self, lambda: b.CreateNumpyVector(x), TypeError)
 
-    def test_create_numpy_vector_reject_object(self):
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            import numpy as np
+    except ImportError:
+      b = flatbuffers.Builder(0)
+      x = 0
+      assertRaises(self, lambda: b.CreateNumpyVector(x),
+                   NumpyRequiredForThisFeature)
 
-            # Create String array
-            b = flatbuffers.Builder(0)
-            x = np.array([{"m": 0}, {"as": -2.1, 'c': 'c'}])
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                TypeError)
+  def test_create_numpy_vector_reject_object(self):
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      import numpy as np
 
-        except ImportError:
-            b = flatbuffers.Builder(0)
-            x = 0
-            assertRaises(
-                self,
-                lambda: b.CreateNumpyVector(x),
-                NumpyRequiredForThisFeature)
+      # Create String array
+      b = flatbuffers.Builder(0)
+      x = np.array([{'m': 0}, {'as': -2.1, 'c': 'c'}])
+      assertRaises(self, lambda: b.CreateNumpyVector(x), TypeError)
 
-    def test_empty_vtable(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(0)
-        self.assertBuilderEquals(b, [])
-        b.EndObject()
-        self.assertBuilderEquals(b, [4, 0, 4, 0, 4, 0, 0, 0])
+    except ImportError:
+      b = flatbuffers.Builder(0)
+      x = 0
+      assertRaises(self, lambda: b.CreateNumpyVector(x),
+                   NumpyRequiredForThisFeature)
 
-    def test_vtable_with_one_true_bool(self):
-        b = flatbuffers.Builder(0)
-        self.assertBuilderEquals(b, [])
-        b.StartObject(1)
-        self.assertBuilderEquals(b, [])
-        b.PrependBoolSlot(0, True, False)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            6, 0,  # vtable bytes
-            8, 0,  # length of object including vtable offset
-            7, 0,  # start of bool value
-            6, 0, 0, 0,  # offset for start of vtable (int32)
-            0, 0, 0,  # padded to 4 bytes
+  def test_empty_vtable(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(0)
+    self.assertBuilderEquals(b, [])
+    b.EndObject()
+    self.assertBuilderEquals(b, [4, 0, 4, 0, 4, 0, 0, 0])
+
+  def test_vtable_with_one_true_bool(self):
+    b = flatbuffers.Builder(0)
+    self.assertBuilderEquals(b, [])
+    b.StartObject(1)
+    self.assertBuilderEquals(b, [])
+    b.PrependBoolSlot(0, True, False)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            6,
+            0,  # vtable bytes
+            8,
+            0,  # length of object including vtable offset
+            7,
+            0,  # start of bool value
+            6,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            0,
+            0,
+            0,  # padded to 4 bytes
             1,  # bool value
         ])
 
-    def test_vtable_with_one_default_bool(self):
-        b = flatbuffers.Builder(0)
-        self.assertBuilderEquals(b, [])
-        b.StartObject(1)
-        self.assertBuilderEquals(b, [])
-        b.PrependBoolSlot(0, False, False)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            4, 0,  # vtable bytes
-            4, 0,  # end of object from here
+  def test_vtable_with_one_default_bool(self):
+    b = flatbuffers.Builder(0)
+    self.assertBuilderEquals(b, [])
+    b.StartObject(1)
+    self.assertBuilderEquals(b, [])
+    b.PrependBoolSlot(0, False, False)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            4,
+            0,  # vtable bytes
+            4,
+            0,  # end of object from here
             # entry 1 is zero and not stored
-            4, 0, 0, 0,  # offset for start of vtable (int32)
+            4,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
         ])
 
-    def test_vtable_with_one_int16(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(1)
-        b.PrependInt16Slot(0, 0x789A, 0)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            6, 0,  # vtable bytes
-            8, 0,  # end of object from here
-            6, 0,  # offset to value
-            6, 0, 0, 0,  # offset for start of vtable (int32)
-            0, 0,  # padding to 4 bytes
-            0x9A, 0x78,
+  def test_vtable_with_one_int16(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(1)
+    b.PrependInt16Slot(0, 0x789A, 0)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            6,
+            0,  # vtable bytes
+            8,
+            0,  # end of object from here
+            6,
+            0,  # offset to value
+            6,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            0,
+            0,  # padding to 4 bytes
+            0x9A,
+            0x78,
         ])
 
-    def test_vtable_with_two_int16(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(2)
-        b.PrependInt16Slot(0, 0x3456, 0)
-        b.PrependInt16Slot(1, 0x789A, 0)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            8, 0,  # vtable bytes
-            8, 0,  # end of object from here
-            6, 0,  # offset to value 0
-            4, 0,  # offset to value 1
-            8, 0, 0, 0,  # offset for start of vtable (int32)
-            0x9A, 0x78,  # value 1
-            0x56, 0x34,  # value 0
+  def test_vtable_with_two_int16(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(2)
+    b.PrependInt16Slot(0, 0x3456, 0)
+    b.PrependInt16Slot(1, 0x789A, 0)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            8,
+            0,  # vtable bytes
+            8,
+            0,  # end of object from here
+            6,
+            0,  # offset to value 0
+            4,
+            0,  # offset to value 1
+            8,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            0x9A,
+            0x78,  # value 1
+            0x56,
+            0x34,  # value 0
         ])
 
-    def test_vtable_with_int16_and_bool(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(2)
-        b.PrependInt16Slot(0, 0x3456, 0)
-        b.PrependBoolSlot(1, True, False)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            8, 0,  # vtable bytes
-            8, 0,  # end of object from here
-            6, 0,  # offset to value 0
-            5, 0,  # offset to value 1
-            8, 0, 0, 0,  # offset for start of vtable (int32)
-            0,          # padding
-            1,          # value 1
-            0x56, 0x34,  # value 0
+  def test_vtable_with_int16_and_bool(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(2)
+    b.PrependInt16Slot(0, 0x3456, 0)
+    b.PrependBoolSlot(1, True, False)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            8,
+            0,  # vtable bytes
+            8,
+            0,  # end of object from here
+            6,
+            0,  # offset to value 0
+            5,
+            0,  # offset to value 1
+            8,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            0,  # padding
+            1,  # value 1
+            0x56,
+            0x34,  # value 0
         ])
 
-    def test_vtable_with_empty_vector(self):
-        b = flatbuffers.Builder(0)
-        b.StartVector(flatbuffers.number_types.Uint8Flags.bytewidth, 0, 1)
-        vecend = b.EndVector()
-        b.StartObject(1)
-        b.PrependUOffsetTRelativeSlot(0, vecend, 0)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            6, 0,  # vtable bytes
-            8, 0,
-            4, 0,  # offset to vector offset
-            6, 0, 0, 0,  # offset for start of vtable (int32)
-            4, 0, 0, 0,
-            0, 0, 0, 0,  # length of vector (not in struct)
+  def test_vtable_with_empty_vector(self):
+    b = flatbuffers.Builder(0)
+    b.StartVector(flatbuffers.number_types.Uint8Flags.bytewidth, 0, 1)
+    vecend = b.EndVector()
+    b.StartObject(1)
+    b.PrependUOffsetTRelativeSlot(0, vecend, 0)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            6,
+            0,  # vtable bytes
+            8,
+            0,
+            4,
+            0,  # offset to vector offset
+            6,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            4,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,  # length of vector (not in struct)
         ])
 
-    def test_vtable_with_empty_vector_of_byte_and_some_scalars(self):
-        b = flatbuffers.Builder(0)
-        b.StartVector(flatbuffers.number_types.Uint8Flags.bytewidth, 0, 1)
-        vecend = b.EndVector()
-        b.StartObject(2)
-        b.PrependInt16Slot(0, 55, 0)
-        b.PrependUOffsetTRelativeSlot(1, vecend, 0)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            8, 0,  # vtable bytes
-            12, 0,
-            10, 0,  # offset to value 0
-            4, 0,  # offset to vector offset
-            8, 0, 0, 0,  # vtable loc
-            8, 0, 0, 0,  # value 1
-            0, 0, 55, 0,  # value 0
-
-            0, 0, 0, 0,  # length of vector (not in struct)
+  def test_vtable_with_empty_vector_of_byte_and_some_scalars(self):
+    b = flatbuffers.Builder(0)
+    b.StartVector(flatbuffers.number_types.Uint8Flags.bytewidth, 0, 1)
+    vecend = b.EndVector()
+    b.StartObject(2)
+    b.PrependInt16Slot(0, 55, 0)
+    b.PrependUOffsetTRelativeSlot(1, vecend, 0)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            8,
+            0,  # vtable bytes
+            12,
+            0,
+            10,
+            0,  # offset to value 0
+            4,
+            0,  # offset to vector offset
+            8,
+            0,
+            0,
+            0,  # vtable loc
+            8,
+            0,
+            0,
+            0,  # value 1
+            0,
+            0,
+            55,
+            0,  # value 0
+            0,
+            0,
+            0,
+            0,  # length of vector (not in struct)
         ])
 
-    def test_vtable_with_1_int16_and_2vector_of_int16(self):
-        b = flatbuffers.Builder(0)
-        b.StartVector(flatbuffers.number_types.Int16Flags.bytewidth, 2, 1)
-        b.PrependInt16(0x1234)
-        b.PrependInt16(0x5678)
-        vecend = b.EndVector()
-        b.StartObject(2)
-        b.PrependUOffsetTRelativeSlot(1, vecend, 0)
-        b.PrependInt16Slot(0, 55, 0)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            8, 0,  # vtable bytes
-            12, 0,  # length of object
-            6, 0,  # start of value 0 from end of vtable
-            8, 0,  # start of value 1 from end of buffer
-            8, 0, 0, 0,  # offset for start of vtable (int32)
-            0, 0,  # padding
-            55, 0,  # value 0
-            4, 0, 0, 0,  # vector position from here
-            2, 0, 0, 0,  # length of vector (uint32)
-            0x78, 0x56,  # vector value 1
-            0x34, 0x12,  # vector value 0
+  def test_vtable_with_1_int16_and_2vector_of_int16(self):
+    b = flatbuffers.Builder(0)
+    b.StartVector(flatbuffers.number_types.Int16Flags.bytewidth, 2, 1)
+    b.PrependInt16(0x1234)
+    b.PrependInt16(0x5678)
+    vecend = b.EndVector()
+    b.StartObject(2)
+    b.PrependUOffsetTRelativeSlot(1, vecend, 0)
+    b.PrependInt16Slot(0, 55, 0)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            8,
+            0,  # vtable bytes
+            12,
+            0,  # length of object
+            6,
+            0,  # start of value 0 from end of vtable
+            8,
+            0,  # start of value 1 from end of buffer
+            8,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            0,
+            0,  # padding
+            55,
+            0,  # value 0
+            4,
+            0,
+            0,
+            0,  # vector position from here
+            2,
+            0,
+            0,
+            0,  # length of vector (uint32)
+            0x78,
+            0x56,  # vector value 1
+            0x34,
+            0x12,  # vector value 0
         ])
 
-    def test_vtable_with_1_struct_of_1_int8__1_int16__1_int32(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(1)
-        b.Prep(4+4+4, 0)
-        b.PrependInt8(55)
-        b.Pad(3)
-        b.PrependInt16(0x1234)
-        b.Pad(2)
-        b.PrependInt32(0x12345678)
-        structStart = b.Offset()
-        b.PrependStructSlot(0, structStart, 0)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            6, 0,  # vtable bytes
-            16, 0,  # end of object from here
-            4, 0,  # start of struct from here
-            6, 0, 0, 0,  # offset for start of vtable (int32)
-            0x78, 0x56, 0x34, 0x12,  # value 2
-            0, 0,  # padding
-            0x34, 0x12,  # value 1
-            0, 0, 0,  # padding
+  def test_vtable_with_1_struct_of_1_int8__1_int16__1_int32(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(1)
+    b.Prep(4 + 4 + 4, 0)
+    b.PrependInt8(55)
+    b.Pad(3)
+    b.PrependInt16(0x1234)
+    b.Pad(2)
+    b.PrependInt32(0x12345678)
+    structStart = b.Offset()
+    b.PrependStructSlot(0, structStart, 0)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            6,
+            0,  # vtable bytes
+            16,
+            0,  # end of object from here
+            4,
+            0,  # start of struct from here
+            6,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            0x78,
+            0x56,
+            0x34,
+            0x12,  # value 2
+            0,
+            0,  # padding
+            0x34,
+            0x12,  # value 1
+            0,
+            0,
+            0,  # padding
             55,  # value 0
         ])
 
-    def test_vtable_with_1_vector_of_2_struct_of_2_int8(self):
-        b = flatbuffers.Builder(0)
-        b.StartVector(flatbuffers.number_types.Int8Flags.bytewidth*2, 2, 1)
-        b.PrependInt8(33)
-        b.PrependInt8(44)
-        b.PrependInt8(55)
-        b.PrependInt8(66)
-        vecend = b.EndVector()
-        b.StartObject(1)
-        b.PrependUOffsetTRelativeSlot(0, vecend, 0)
-        b.EndObject()
-        self.assertBuilderEquals(b, [
-            6, 0,  # vtable bytes
-            8, 0,
-            4, 0,  # offset of vector offset
-            6, 0, 0, 0,  # offset for start of vtable (int32)
-            4, 0, 0, 0,  # vector start offset
-
-            2, 0, 0, 0,  # vector length
+  def test_vtable_with_1_vector_of_2_struct_of_2_int8(self):
+    b = flatbuffers.Builder(0)
+    b.StartVector(flatbuffers.number_types.Int8Flags.bytewidth * 2, 2, 1)
+    b.PrependInt8(33)
+    b.PrependInt8(44)
+    b.PrependInt8(55)
+    b.PrependInt8(66)
+    vecend = b.EndVector()
+    b.StartObject(1)
+    b.PrependUOffsetTRelativeSlot(0, vecend, 0)
+    b.EndObject()
+    self.assertBuilderEquals(
+        b,
+        [
+            6,
+            0,  # vtable bytes
+            8,
+            0,
+            4,
+            0,  # offset of vector offset
+            6,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            4,
+            0,
+            0,
+            0,  # vector start offset
+            2,
+            0,
+            0,
+            0,  # vector length
             66,  # vector value 1,1
             55,  # vector value 1,0
             44,  # vector value 0,1
             33,  # vector value 0,0
         ])
 
-    def test_table_with_some_elements(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(2)
-        b.PrependInt8Slot(0, 33, 0)
-        b.PrependInt16Slot(1, 66, 0)
-        off = b.EndObject()
-        b.Finish(off)
+  def test_table_with_some_elements(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(2)
+    b.PrependInt8Slot(0, 33, 0)
+    b.PrependInt16Slot(1, 66, 0)
+    off = b.EndObject()
+    b.Finish(off)
 
-        self.assertBuilderEquals(b, [
-            12, 0, 0, 0,  # root of table: points to vtable offset
-
-            8, 0,  # vtable bytes
-            8, 0,  # end of object from here
-            7, 0,  # start of value 0
-            4, 0,  # start of value 1
-
-            8, 0, 0, 0,  # offset for start of vtable (int32)
-
-            66, 0,  # value 1
+    self.assertBuilderEquals(
+        b,
+        [
+            12,
+            0,
+            0,
+            0,  # root of table: points to vtable offset
+            8,
+            0,  # vtable bytes
+            8,
+            0,  # end of object from here
+            7,
+            0,  # start of value 0
+            4,
+            0,  # start of value 1
+            8,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            66,
+            0,  # value 1
             0,  # padding
             33,  # value 0
         ])
 
-    def test__one_unfinished_table_and_one_finished_table(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(2)
-        b.PrependInt8Slot(0, 33, 0)
-        b.PrependInt8Slot(1, 44, 0)
-        off = b.EndObject()
-        b.Finish(off)
+  def test__one_unfinished_table_and_one_finished_table(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(2)
+    b.PrependInt8Slot(0, 33, 0)
+    b.PrependInt8Slot(1, 44, 0)
+    off = b.EndObject()
+    b.Finish(off)
 
-        b.StartObject(3)
-        b.PrependInt8Slot(0, 55, 0)
-        b.PrependInt8Slot(1, 66, 0)
-        b.PrependInt8Slot(2, 77, 0)
-        off = b.EndObject()
-        b.Finish(off)
+    b.StartObject(3)
+    b.PrependInt8Slot(0, 55, 0)
+    b.PrependInt8Slot(1, 66, 0)
+    b.PrependInt8Slot(2, 77, 0)
+    off = b.EndObject()
+    b.Finish(off)
 
-        self.assertBuilderEquals(b, [
-            16, 0, 0, 0,  # root of table: points to object
-            0, 0,  # padding
-
-            10, 0,  # vtable bytes
-            8, 0,  # size of object
-            7, 0,  # start of value 0
-            6, 0,  # start of value 1
-            5, 0,  # start of value 2
-            10, 0, 0, 0,  # offset for start of vtable (int32)
+    self.assertBuilderEquals(
+        b,
+        [
+            16,
+            0,
+            0,
+            0,  # root of table: points to object
+            0,
+            0,  # padding
+            10,
+            0,  # vtable bytes
+            8,
+            0,  # size of object
+            7,
+            0,  # start of value 0
+            6,
+            0,  # start of value 1
+            5,
+            0,  # start of value 2
+            10,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
             0,  # padding
             77,  # value 2
             66,  # value 1
             55,  # value 0
-
-            12, 0, 0, 0,  # root of table: points to object
-
-            8, 0,  # vtable bytes
-            8, 0,  # size of object
-            7, 0,  # start of value 0
-            6, 0,  # start of value 1
-            8, 0, 0, 0,  # offset for start of vtable (int32)
-            0, 0,  # padding
+            12,
+            0,
+            0,
+            0,  # root of table: points to object
+            8,
+            0,  # vtable bytes
+            8,
+            0,  # size of object
+            7,
+            0,  # start of value 0
+            6,
+            0,  # start of value 1
+            8,
+            0,
+            0,
+            0,  # offset for start of vtable (int32)
+            0,
+            0,  # padding
             44,  # value 1
             33,  # value 0
         ])
 
-    def test_a_bunch_of_bools(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(8)
-        b.PrependBoolSlot(0, True, False)
-        b.PrependBoolSlot(1, True, False)
-        b.PrependBoolSlot(2, True, False)
-        b.PrependBoolSlot(3, True, False)
-        b.PrependBoolSlot(4, True, False)
-        b.PrependBoolSlot(5, True, False)
-        b.PrependBoolSlot(6, True, False)
-        b.PrependBoolSlot(7, True, False)
-        off = b.EndObject()
-        b.Finish(off)
-
-        self.assertBuilderEquals(b, [
-            24, 0, 0, 0,  # root of table: points to vtable offset
-
-            20, 0,  # vtable bytes
-            12, 0,  # size of object
-            11, 0,  # start of value 0
-            10, 0,  # start of value 1
-            9, 0,  # start of value 2
-            8, 0,  # start of value 3
-            7, 0,  # start of value 4
-            6, 0,  # start of value 5
-            5, 0,  # start of value 6
-            4, 0,  # start of value 7
-            20, 0, 0, 0,  # vtable offset
+  def test_a_bunch_of_bools(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(8)
+    b.PrependBoolSlot(0, True, False)
+    b.PrependBoolSlot(1, True, False)
+    b.PrependBoolSlot(2, True, False)
+    b.PrependBoolSlot(3, True, False)
+    b.PrependBoolSlot(4, True, False)
+    b.PrependBoolSlot(5, True, False)
+    b.PrependBoolSlot(6, True, False)
+    b.PrependBoolSlot(7, True, False)
+    off = b.EndObject()
+    b.Finish(off)
 
+    self.assertBuilderEquals(
+        b,
+        [
+            24,
+            0,
+            0,
+            0,  # root of table: points to vtable offset
+            20,
+            0,  # vtable bytes
+            12,
+            0,  # size of object
+            11,
+            0,  # start of value 0
+            10,
+            0,  # start of value 1
+            9,
+            0,  # start of value 2
+            8,
+            0,  # start of value 3
+            7,
+            0,  # start of value 4
+            6,
+            0,  # start of value 5
+            5,
+            0,  # start of value 6
+            4,
+            0,  # start of value 7
+            20,
+            0,
+            0,
+            0,  # vtable offset
             1,  # value 7
             1,  # value 6
             1,  # value 5
@@ -1498,937 +1885,970 @@ class TestByteLayout(unittest.TestCase):
             1,  # value 0
         ])
 
-    def test_three_bools(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(3)
-        b.PrependBoolSlot(0, True, False)
-        b.PrependBoolSlot(1, True, False)
-        b.PrependBoolSlot(2, True, False)
-        off = b.EndObject()
-        b.Finish(off)
-
-        self.assertBuilderEquals(b, [
-            16, 0, 0, 0,  # root of table: points to vtable offset
-
-            0, 0,  # padding
-
-            10, 0,  # vtable bytes
-            8, 0,  # size of object
-            7, 0,  # start of value 0
-            6, 0,  # start of value 1
-            5, 0,  # start of value 2
-            10, 0, 0, 0,  # vtable offset from here
+  def test_three_bools(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(3)
+    b.PrependBoolSlot(0, True, False)
+    b.PrependBoolSlot(1, True, False)
+    b.PrependBoolSlot(2, True, False)
+    off = b.EndObject()
+    b.Finish(off)
 
+    self.assertBuilderEquals(
+        b,
+        [
+            16,
+            0,
+            0,
+            0,  # root of table: points to vtable offset
+            0,
+            0,  # padding
+            10,
+            0,  # vtable bytes
+            8,
+            0,  # size of object
+            7,
+            0,  # start of value 0
+            6,
+            0,  # start of value 1
+            5,
+            0,  # start of value 2
+            10,
+            0,
+            0,
+            0,  # vtable offset from here
             0,  # padding
             1,  # value 2
             1,  # value 1
             1,  # value 0
         ])
 
-    def test_some_floats(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(1)
-        b.PrependFloat32Slot(0, 1.0, 0.0)
-        off = b.EndObject()
+  def test_some_floats(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(1)
+    b.PrependFloat32Slot(0, 1.0, 0.0)
+    off = b.EndObject()
 
-        self.assertBuilderEquals(b, [
-            6, 0,  # vtable bytes
-            8, 0,  # size of object
-            4, 0,  # start of value 0
-            6, 0, 0, 0,  # vtable offset
-
-            0, 0, 128, 63,  # value 0
+    self.assertBuilderEquals(
+        b,
+        [
+            6,
+            0,  # vtable bytes
+            8,
+            0,  # size of object
+            4,
+            0,  # start of value 0
+            6,
+            0,
+            0,
+            0,  # vtable offset
+            0,
+            0,
+            128,
+            63,  # value 0
         ])
 
 
-def make_monster_from_generated_code(sizePrefix = False, file_identifier=None):
-    ''' Use generated code to build the example Monster. '''
+def make_monster_from_generated_code(sizePrefix=False, file_identifier=None):
+  """ Use generated code to build the example Monster. """
 
-    b = flatbuffers.Builder(0)
-    string = b.CreateString("MyMonster")
-    test1 = b.CreateString("test1")
-    test2 = b.CreateString("test2")
-    fred = b.CreateString("Fred")
+  b = flatbuffers.Builder(0)
+  string = b.CreateString('MyMonster')
+  test1 = b.CreateString('test1')
+  test2 = b.CreateString('test2')
+  fred = b.CreateString('Fred')
 
-    MyGame.Example.Monster.StartInventoryVector(b, 5)
-    b.PrependByte(4)
-    b.PrependByte(3)
-    b.PrependByte(2)
-    b.PrependByte(1)
-    b.PrependByte(0)
-    inv = b.EndVector()
+  _MONSTER.MonsterStartInventoryVector(b, 5)
+  b.PrependByte(4)
+  b.PrependByte(3)
+  b.PrependByte(2)
+  b.PrependByte(1)
+  b.PrependByte(0)
+  inv = b.EndVector()
 
-    MyGame.Example.Monster.Start(b)
-    MyGame.Example.Monster.AddName(b, fred)
-    mon2 = MyGame.Example.Monster.End(b)
+  _MONSTER.MonsterStart(b)
+  _MONSTER.MonsterAddName(b, fred)
+  mon2 = _MONSTER.MonsterEnd(b)
 
-    MyGame.Example.Monster.StartTest4Vector(b, 2)
-    MyGame.Example.Test.CreateTest(b, 10, 20)
-    MyGame.Example.Test.CreateTest(b, 30, 40)
-    test4 = b.EndVector()
+  _MONSTER.MonsterStartTest4Vector(b, 2)
+  _TEST.CreateTest(b, 10, 20)
+  _TEST.CreateTest(b, 30, 40)
+  test4 = b.EndVector()
 
-    MyGame.Example.Monster.StartTestarrayofstringVector(b, 2)
-    b.PrependUOffsetTRelative(test2)
-    b.PrependUOffsetTRelative(test1)
-    testArrayOfString = b.EndVector()
+  _MONSTER.MonsterStartTestarrayofstringVector(b, 2)
+  b.PrependUOffsetTRelative(test2)
+  b.PrependUOffsetTRelative(test1)
+  testArrayOfString = b.EndVector()
 
-    MyGame.Example.Monster.StartVectorOfLongsVector(b, 5)
-    b.PrependInt64(100000000)
-    b.PrependInt64(1000000)
-    b.PrependInt64(10000)
-    b.PrependInt64(100)
-    b.PrependInt64(1)
-    VectorOfLongs = b.EndVector()
+  _MONSTER.MonsterStartVectorOfLongsVector(b, 5)
+  b.PrependInt64(100000000)
+  b.PrependInt64(1000000)
+  b.PrependInt64(10000)
+  b.PrependInt64(100)
+  b.PrependInt64(1)
+  VectorOfLongs = b.EndVector()
 
-    MyGame.Example.Monster.StartVectorOfDoublesVector(b, 3)
-    b.PrependFloat64(1.7976931348623157e+308)
-    b.PrependFloat64(0)
-    b.PrependFloat64(-1.7976931348623157e+308)
-    VectorOfDoubles = b.EndVector()
+  _MONSTER.MonsterStartVectorOfDoublesVector(b, 3)
+  b.PrependFloat64(1.7976931348623157e+308)
+  b.PrependFloat64(0)
+  b.PrependFloat64(-1.7976931348623157e+308)
+  VectorOfDoubles = b.EndVector()
 
-    MyGame.Example.Monster.Start(b)
+  _MONSTER.MonsterStart(b)
 
-    pos = MyGame.Example.Vec3.CreateVec3(b, 1.0, 2.0, 3.0, 3.0, 2, 5, 6)
-    MyGame.Example.Monster.AddPos(b, pos)
+  pos = _VEC3.CreateVec3(b, 1.0, 2.0, 3.0, 3.0, 2, 5, 6)
+  _MONSTER.MonsterAddPos(b, pos)
 
-    MyGame.Example.Monster.AddHp(b, 80)
-    MyGame.Example.Monster.AddName(b, string)
-    MyGame.Example.Monster.AddInventory(b, inv)
-    MyGame.Example.Monster.AddTestType(b, 1)
-    MyGame.Example.Monster.AddTest(b, mon2)
-    MyGame.Example.Monster.AddTest4(b, test4)
-    MyGame.Example.Monster.AddTestarrayofstring(b, testArrayOfString)
-    MyGame.Example.Monster.AddVectorOfLongs(b, VectorOfLongs)
-    MyGame.Example.Monster.AddVectorOfDoubles(b, VectorOfDoubles)
-    mon = MyGame.Example.Monster.End(b)
+  _MONSTER.MonsterAddHp(b, 80)
+  _MONSTER.MonsterAddName(b, string)
+  _MONSTER.MonsterAddInventory(b, inv)
+  _MONSTER.MonsterAddTestType(b, 1)
+  _MONSTER.MonsterAddTest(b, mon2)
+  _MONSTER.MonsterAddTest4(b, test4)
+  _MONSTER.MonsterAddTestarrayofstring(b, testArrayOfString)
+  _MONSTER.MonsterAddVectorOfLongs(b, VectorOfLongs)
+  _MONSTER.MonsterAddVectorOfDoubles(b, VectorOfDoubles)
+  mon = _MONSTER.MonsterEnd(b)
 
-    if sizePrefix:
-        b.FinishSizePrefixed(mon, file_identifier)
-    else:
-        b.Finish(mon, file_identifier)
+  if sizePrefix:
+    b.FinishSizePrefixed(mon, file_identifier)
+  else:
+    b.Finish(mon, file_identifier)
 
-    return b.Bytes, b.Head()
+  return b.Bytes, b.Head()
 
 
 class TestBuilderForceDefaults(unittest.TestCase):
-    """Verify that the builder adds default values when forced."""
+  """Verify that the builder adds default values when forced."""
 
-    test_flags = [N.BoolFlags(), N.Uint8Flags(), N.Uint16Flags(), \
-                  N.Uint32Flags(), N.Uint64Flags(), N.Int8Flags(), \
-                  N.Int16Flags(), N.Int32Flags(), N.Int64Flags(), \
-                  N.Float32Flags(), N.Float64Flags(), N.UOffsetTFlags()]
-    def test_default_force_defaults(self):
-        for flag in self.test_flags:
-            b = flatbuffers.Builder(0)
-            b.StartObject(1)
-            stored_offset = b.Offset()
-            if flag != N.UOffsetTFlags():
-                b.PrependSlot(flag, 0, 0, 0)
-            else:
-                b.PrependUOffsetTRelativeSlot(0, 0, 0)
-            end_offset = b.Offset()
-            b.EndObject()
-            self.assertEqual(0, end_offset - stored_offset)
+  test_flags = [N.BoolFlags(), N.Uint8Flags(), N.Uint16Flags(), \
+                N.Uint32Flags(), N.Uint64Flags(), N.Int8Flags(), \
+                N.Int16Flags(), N.Int32Flags(), N.Int64Flags(), \
+                N.Float32Flags(), N.Float64Flags(), N.UOffsetTFlags()]
 
-    def test_force_defaults_true(self):
-        for flag in self.test_flags:
-            b = flatbuffers.Builder(0)
-            b.ForceDefaults(True)
-            b.StartObject(1)
-            stored_offset = b.Offset()
-            if flag != N.UOffsetTFlags():
-                b.PrependSlot(flag, 0, 0, 0)
-            else:
-                b.PrependUOffsetTRelativeSlot(0, 0, 0)
-            end_offset = b.Offset()
-            b.EndObject()
-            self.assertEqual(flag.bytewidth, end_offset - stored_offset)
+  def test_default_force_defaults(self):
+    for flag in self.test_flags:
+      b = flatbuffers.Builder(0)
+      b.StartObject(1)
+      stored_offset = b.Offset()
+      if flag != N.UOffsetTFlags():
+        b.PrependSlot(flag, 0, 0, 0)
+      else:
+        b.PrependUOffsetTRelativeSlot(0, 0, 0)
+      end_offset = b.Offset()
+      b.EndObject()
+      self.assertEqual(0, end_offset - stored_offset)
+
+  def test_force_defaults_true(self):
+    for flag in self.test_flags:
+      b = flatbuffers.Builder(0)
+      b.ForceDefaults(True)
+      b.StartObject(1)
+      stored_offset = b.Offset()
+      if flag != N.UOffsetTFlags():
+        b.PrependSlot(flag, 0, 0, 0)
+      else:
+        b.PrependUOffsetTRelativeSlot(0, 0, 0)
+      end_offset = b.Offset()
+      b.EndObject()
+      self.assertEqual(flag.bytewidth, end_offset - stored_offset)
 
 
 class TestAllCodePathsOfExampleSchema(unittest.TestCase):
-    def setUp(self, *args, **kwargs):
-        super(TestAllCodePathsOfExampleSchema, self).setUp(*args, **kwargs)
 
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.Start(b)
-        gen_mon = MyGame.Example.Monster.End(b)
-        b.Finish(gen_mon)
+  def setUp(self, *args, **kwargs):
+    super(TestAllCodePathsOfExampleSchema, self).setUp(*args, **kwargs)
 
-        self.mon = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                                   b.Head())
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStart(b)
+    gen_mon = _MONSTER.MonsterEnd(b)
+    b.Finish(gen_mon)
 
-    def test_default_monster_pos(self):
-        self.assertTrue(self.mon.Pos() is None)
+    self.mon = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
 
-    def test_nondefault_monster_mana(self):
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddMana(b, 50)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+  def test_default_monster_pos(self):
+    self.assertTrue(self.mon.Pos() is None)
 
-        got_mon = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                                  b.Head())
-        self.assertEqual(50, got_mon.Mana())
+  def test_nondefault_monster_mana(self):
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddMana(b, 50)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_default_monster_hp(self):
-        self.assertEqual(100, self.mon.Hp())
+    got_mon = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertEqual(50, got_mon.Mana())
 
-    def test_default_monster_name(self):
-        self.assertEqual(None, self.mon.Name())
+  def test_default_monster_hp(self):
+    self.assertEqual(100, self.mon.Hp())
 
-    def test_default_monster_inventory_item(self):
-        self.assertEqual(0, self.mon.Inventory(0))
+  def test_default_monster_name(self):
+    self.assertEqual(None, self.mon.Name())
 
-    def test_default_monster_inventory_length(self):
-        self.assertEqual(0, self.mon.InventoryLength())
-        self.assertTrue(self.mon.InventoryIsNone())
+  def test_default_monster_inventory_item(self):
+    self.assertEqual(0, self.mon.Inventory(0))
 
-    def test_empty_monster_inventory_vector(self):
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.StartInventoryVector(b, 0)
-        inv = b.EndVector()
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddInventory(b, inv)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertFalse(mon2.InventoryIsNone())
+  def test_default_monster_inventory_length(self):
+    self.assertEqual(0, self.mon.InventoryLength())
+    self.assertTrue(self.mon.InventoryIsNone())
 
-    def test_default_monster_color(self):
-        self.assertEqual(MyGame.Example.Color.Color.Blue, self.mon.Color())
+  def test_empty_monster_inventory_vector(self):
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStartInventoryVector(b, 0)
+    inv = b.EndVector()
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddInventory(b, inv)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertFalse(mon2.InventoryIsNone())
 
-    def test_nondefault_monster_color(self):
-        b = flatbuffers.Builder(0)
-        color = MyGame.Example.Color.Color.Red
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddColor(b, color)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+  def test_default_monster_color(self):
+    self.assertEqual(_COLOR.Color.Blue, self.mon.Color())
 
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertEqual(MyGame.Example.Color.Color.Red, mon2.Color())
+  def test_nondefault_monster_color(self):
+    b = flatbuffers.Builder(0)
+    color = _COLOR.Color.Red
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddColor(b, color)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_default_monster_testtype(self):
-        self.assertEqual(0, self.mon.TestType())
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertEqual(_COLOR.Color.Red, mon2.Color())
 
-    def test_default_monster_test_field(self):
-        self.assertEqual(None, self.mon.Test())
+  def test_default_monster_testtype(self):
+    self.assertEqual(0, self.mon.TestType())
 
-    def test_default_monster_test4_item(self):
-        self.assertEqual(None, self.mon.Test4(0))
+  def test_default_monster_test_field(self):
+    self.assertEqual(None, self.mon.Test())
 
-    def test_default_monster_test4_length(self):
-        self.assertEqual(0, self.mon.Test4Length())
-        self.assertTrue(self.mon.Test4IsNone())
+  def test_default_monster_test4_item(self):
+    self.assertEqual(None, self.mon.Test4(0))
 
-    def test_empty_monster_test4_vector(self):
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.StartTest4Vector(b, 0)
-        test4 = b.EndVector()
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTest4(b, test4)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertFalse(mon2.Test4IsNone())
+  def test_default_monster_test4_length(self):
+    self.assertEqual(0, self.mon.Test4Length())
+    self.assertTrue(self.mon.Test4IsNone())
 
-    def test_default_monster_testarrayofstring(self):
-        self.assertEqual("", self.mon.Testarrayofstring(0))
+  def test_empty_monster_test4_vector(self):
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStartTest4Vector(b, 0)
+    test4 = b.EndVector()
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTest4(b, test4)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertFalse(mon2.Test4IsNone())
 
-    def test_default_monster_testarrayofstring_length(self):
-        self.assertEqual(0, self.mon.TestarrayofstringLength())
-        self.assertTrue(self.mon.TestarrayofstringIsNone())
+  def test_default_monster_testarrayofstring(self):
+    self.assertEqual('', self.mon.Testarrayofstring(0))
 
-    def test_empty_monster_testarrayofstring_vector(self):
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.StartTestarrayofstringVector(b, 0)
-        testarrayofstring = b.EndVector()
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTestarrayofstring(b, testarrayofstring)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertFalse(mon2.TestarrayofstringIsNone())
+  def test_default_monster_testarrayofstring_length(self):
+    self.assertEqual(0, self.mon.TestarrayofstringLength())
+    self.assertTrue(self.mon.TestarrayofstringIsNone())
 
-    def test_default_monster_testarrayoftables(self):
-        self.assertEqual(None, self.mon.Testarrayoftables(0))
+  def test_empty_monster_testarrayofstring_vector(self):
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStartTestarrayofstringVector(b, 0)
+    testarrayofstring = b.EndVector()
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTestarrayofstring(b, testarrayofstring)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertFalse(mon2.TestarrayofstringIsNone())
 
-    def test_nondefault_monster_testarrayoftables(self):
-        b = flatbuffers.Builder(0)
+  def test_default_monster_testarrayoftables(self):
+    self.assertEqual(None, self.mon.Testarrayoftables(0))
 
-        # make a child Monster within a vector of Monsters:
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddHp(b, 99)
-        sub_monster = MyGame.Example.Monster.End(b)
+  def test_nondefault_monster_testarrayoftables(self):
+    b = flatbuffers.Builder(0)
 
-        # build the vector:
-        MyGame.Example.Monster.StartTestarrayoftablesVector(b, 1)
-        b.PrependUOffsetTRelative(sub_monster)
-        vec = b.EndVector()
+    # make a child Monster within a vector of Monsters:
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddHp(b, 99)
+    sub_monster = _MONSTER.MonsterEnd(b)
 
-        # make the parent monster and include the vector of Monster:
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTestarrayoftables(b, vec)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+    # build the vector:
+    _MONSTER.MonsterStartTestarrayoftablesVector(b, 1)
+    b.PrependUOffsetTRelative(sub_monster)
+    vec = b.EndVector()
 
-        # inspect the resulting data:
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Output(), 0)
-        self.assertEqual(99, mon2.Testarrayoftables(0).Hp())
-        self.assertEqual(1, mon2.TestarrayoftablesLength())
-        self.assertFalse(mon2.TestarrayoftablesIsNone())
+    # make the parent monster and include the vector of Monster:
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTestarrayoftables(b, vec)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_default_monster_testarrayoftables_length(self):
-        self.assertEqual(0, self.mon.TestarrayoftablesLength())
-        self.assertTrue(self.mon.TestarrayoftablesIsNone())
+    # inspect the resulting data:
+    mon2 = _MONSTER.Monster.GetRootAs(b.Output(), 0)
+    self.assertEqual(99, mon2.Testarrayoftables(0).Hp())
+    self.assertEqual(1, mon2.TestarrayoftablesLength())
+    self.assertFalse(mon2.TestarrayoftablesIsNone())
 
-    def test_empty_monster_testarrayoftables_vector(self):
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.StartTestarrayoftablesVector(b, 0)
-        testarrayoftables = b.EndVector()
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTestarrayoftables(b, testarrayoftables)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertFalse(mon2.TestarrayoftablesIsNone())
+  def test_default_monster_testarrayoftables_length(self):
+    self.assertEqual(0, self.mon.TestarrayoftablesLength())
+    self.assertTrue(self.mon.TestarrayoftablesIsNone())
 
-    def test_default_monster_testarrayoftables_length(self):
-        self.assertEqual(0, self.mon.TestarrayoftablesLength())
+  def test_empty_monster_testarrayoftables_vector(self):
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStartTestarrayoftablesVector(b, 0)
+    testarrayoftables = b.EndVector()
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTestarrayoftables(b, testarrayoftables)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertFalse(mon2.TestarrayoftablesIsNone())
 
-    def test_nondefault_monster_enemy(self):
-        b = flatbuffers.Builder(0)
+  def test_default_monster_testarrayoftables_length(self):
+    self.assertEqual(0, self.mon.TestarrayoftablesLength())
 
-        # make an Enemy object:
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddHp(b, 88)
-        enemy = MyGame.Example.Monster.End(b)
-        b.Finish(enemy)
+  def test_nondefault_monster_enemy(self):
+    b = flatbuffers.Builder(0)
 
-        # make the parent monster and include the vector of Monster:
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddEnemy(b, enemy)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+    # make an Enemy object:
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddHp(b, 88)
+    enemy = _MONSTER.MonsterEnd(b)
+    b.Finish(enemy)
 
-        # inspect the resulting data:
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertEqual(88, mon2.Enemy().Hp())
+    # make the parent monster and include the vector of Monster:
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddEnemy(b, enemy)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_default_monster_testnestedflatbuffer(self):
-        self.assertEqual(0, self.mon.Testnestedflatbuffer(0))
+    # inspect the resulting data:
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertEqual(88, mon2.Enemy().Hp())
 
-    def test_default_monster_testnestedflatbuffer_length(self):
-        self.assertEqual(0, self.mon.TestnestedflatbufferLength())
-        self.assertTrue(self.mon.TestnestedflatbufferIsNone())
+  def test_default_monster_testnestedflatbuffer(self):
+    self.assertEqual(0, self.mon.Testnestedflatbuffer(0))
 
-    def test_empty_monster_testnestedflatbuffer_vector(self):
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.StartTestnestedflatbufferVector(b, 0)
-        testnestedflatbuffer = b.EndVector()
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTestnestedflatbuffer(b, testnestedflatbuffer)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertFalse(mon2.TestnestedflatbufferIsNone())
+  def test_default_monster_testnestedflatbuffer_length(self):
+    self.assertEqual(0, self.mon.TestnestedflatbufferLength())
+    self.assertTrue(self.mon.TestnestedflatbufferIsNone())
 
-    def test_nondefault_monster_testnestedflatbuffer(self):
-        b = flatbuffers.Builder(0)
+  def test_empty_monster_testnestedflatbuffer_vector(self):
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStartTestnestedflatbufferVector(b, 0)
+    testnestedflatbuffer = b.EndVector()
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTestnestedflatbuffer(b, testnestedflatbuffer)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertFalse(mon2.TestnestedflatbufferIsNone())
 
-        MyGame.Example.Monster.StartTestnestedflatbufferVector(b, 3)
-        b.PrependByte(4)
-        b.PrependByte(2)
-        b.PrependByte(0)
-        sub_buf = b.EndVector()
+  def test_nondefault_monster_testnestedflatbuffer(self):
+    b = flatbuffers.Builder(0)
 
-        # make the parent monster and include the vector of Monster:
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTestnestedflatbuffer(b, sub_buf)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+    _MONSTER.MonsterStartTestnestedflatbufferVector(b, 3)
+    b.PrependByte(4)
+    b.PrependByte(2)
+    b.PrependByte(0)
+    sub_buf = b.EndVector()
 
-        # inspect the resulting data:
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertEqual(3, mon2.TestnestedflatbufferLength())
-        self.assertFalse(mon2.TestnestedflatbufferIsNone())
-        self.assertEqual(0, mon2.Testnestedflatbuffer(0))
-        self.assertEqual(2, mon2.Testnestedflatbuffer(1))
-        self.assertEqual(4, mon2.Testnestedflatbuffer(2))
-        try:
-            imp.find_module('numpy')
-            # if numpy exists, then we should be able to get the
-            # vector as a numpy array
-            self.assertEqual([0, 2, 4], mon2.TestnestedflatbufferAsNumpy().tolist())
-        except ImportError:
-            assertRaises(self,
-                         lambda: mon2.TestnestedflatbufferAsNumpy(),
-                         NumpyRequiredForThisFeature)
+    # make the parent monster and include the vector of Monster:
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTestnestedflatbuffer(b, sub_buf)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_nested_monster_testnestedflatbuffer(self):
-        b = flatbuffers.Builder(0)
+    # inspect the resulting data:
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertEqual(3, mon2.TestnestedflatbufferLength())
+    self.assertFalse(mon2.TestnestedflatbufferIsNone())
+    self.assertEqual(0, mon2.Testnestedflatbuffer(0))
+    self.assertEqual(2, mon2.Testnestedflatbuffer(1))
+    self.assertEqual(4, mon2.Testnestedflatbuffer(2))
+    try:
+      imp.find_module('numpy')
+      # if numpy exists, then we should be able to get the
+      # vector as a numpy array
+      self.assertEqual([0, 2, 4], mon2.TestnestedflatbufferAsNumpy().tolist())
+    except ImportError:
+      assertRaises(self, lambda: mon2.TestnestedflatbufferAsNumpy(),
+                   NumpyRequiredForThisFeature)
 
-        # build another monster to nest inside testnestedflatbuffer
-        nestedB = flatbuffers.Builder(0)
-        nameStr = nestedB.CreateString("Nested Monster")
-        MyGame.Example.Monster.Start(nestedB)
-        MyGame.Example.Monster.AddHp(nestedB, 30)
-        MyGame.Example.Monster.AddName(nestedB, nameStr)
-        nestedMon = MyGame.Example.Monster.End(nestedB)
-        nestedB.Finish(nestedMon)
+  def test_nested_monster_testnestedflatbuffer(self):
+    b = flatbuffers.Builder(0)
 
-        # write the nested FB bytes
-        sub_buf = MyGame.Example.Monster.MakeTestnestedflatbufferVectorFromBytes(
-            b, nestedB.Output())
+    # build another monster to nest inside testnestedflatbuffer
+    nestedB = flatbuffers.Builder(0)
+    nameStr = nestedB.CreateString('Nested Monster')
+    _MONSTER.MonsterStart(nestedB)
+    _MONSTER.MonsterAddHp(nestedB, 30)
+    _MONSTER.MonsterAddName(nestedB, nameStr)
+    nestedMon = _MONSTER.MonsterEnd(nestedB)
+    nestedB.Finish(nestedMon)
 
-        # make the parent monster and include the bytes of the nested monster
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTestnestedflatbuffer(b, sub_buf)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+    # write the nested FB bytes
+    sub_buf = _MONSTER.MonsterMakeTestnestedflatbufferVectorFromBytes(
+        b, nestedB.Output())
 
-        # inspect the resulting data:
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        nestedMon2 = mon2.TestnestedflatbufferNestedRoot()
-        self.assertEqual(b"Nested Monster", nestedMon2.Name())
-        self.assertEqual(30, nestedMon2.Hp())
+    # make the parent monster and include the bytes of the nested monster
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTestnestedflatbuffer(b, sub_buf)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_nondefault_monster_testempty(self):
-        b = flatbuffers.Builder(0)
+    # inspect the resulting data:
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    nestedMon2 = mon2.TestnestedflatbufferNestedRoot()
+    self.assertEqual(b'Nested Monster', nestedMon2.Name())
+    self.assertEqual(30, nestedMon2.Hp())
 
-        # make a Stat object:
-        MyGame.Example.Stat.Start(b)
-        MyGame.Example.Stat.AddVal(b, 123)
-        my_stat = MyGame.Example.Stat.End(b)
-        b.Finish(my_stat)
+  def test_nondefault_monster_testempty(self):
+    b = flatbuffers.Builder(0)
 
-        # include the stat object in a monster:
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTestempty(b, my_stat)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+    # make a Stat object:
+    _STAT.StatStart(b)
+    _STAT.StatAddVal(b, 123)
+    my_stat = _STAT.StatEnd(b)
+    b.Finish(my_stat)
 
-        # inspect the resulting data:
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertEqual(123, mon2.Testempty().Val())
+    # include the stat object in a monster:
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTestempty(b, my_stat)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_default_monster_testbool(self):
-        self.assertFalse(self.mon.Testbool())
+    # inspect the resulting data:
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertEqual(123, mon2.Testempty().Val())
 
-    def test_nondefault_monster_testbool(self):
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTestbool(b, True)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+  def test_default_monster_testbool(self):
+    self.assertFalse(self.mon.Testbool())
 
-        # inspect the resulting data:
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertTrue(mon2.Testbool())
+  def test_nondefault_monster_testbool(self):
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTestbool(b, True)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_default_monster_testhashes(self):
-        self.assertEqual(0, self.mon.Testhashs32Fnv1())
-        self.assertEqual(0, self.mon.Testhashu32Fnv1())
-        self.assertEqual(0, self.mon.Testhashs64Fnv1())
-        self.assertEqual(0, self.mon.Testhashu64Fnv1())
-        self.assertEqual(0, self.mon.Testhashs32Fnv1a())
-        self.assertEqual(0, self.mon.Testhashu32Fnv1a())
-        self.assertEqual(0, self.mon.Testhashs64Fnv1a())
-        self.assertEqual(0, self.mon.Testhashu64Fnv1a())
+    # inspect the resulting data:
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertTrue(mon2.Testbool())
 
-    def test_nondefault_monster_testhashes(self):
-        b = flatbuffers.Builder(0)
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddTesthashs32Fnv1(b, 1)
-        MyGame.Example.Monster.AddTesthashu32Fnv1(b, 2)
-        MyGame.Example.Monster.AddTesthashs64Fnv1(b, 3)
-        MyGame.Example.Monster.AddTesthashu64Fnv1(b, 4)
-        MyGame.Example.Monster.AddTesthashs32Fnv1a(b, 5)
-        MyGame.Example.Monster.AddTesthashu32Fnv1a(b, 6)
-        MyGame.Example.Monster.AddTesthashs64Fnv1a(b, 7)
-        MyGame.Example.Monster.AddTesthashu64Fnv1a(b, 8)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+  def test_default_monster_testhashes(self):
+    self.assertEqual(0, self.mon.Testhashs32Fnv1())
+    self.assertEqual(0, self.mon.Testhashu32Fnv1())
+    self.assertEqual(0, self.mon.Testhashs64Fnv1())
+    self.assertEqual(0, self.mon.Testhashu64Fnv1())
+    self.assertEqual(0, self.mon.Testhashs32Fnv1a())
+    self.assertEqual(0, self.mon.Testhashu32Fnv1a())
+    self.assertEqual(0, self.mon.Testhashs64Fnv1a())
+    self.assertEqual(0, self.mon.Testhashu64Fnv1a())
 
-        # inspect the resulting data:
-        mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                               b.Head())
-        self.assertEqual(1, mon2.Testhashs32Fnv1())
-        self.assertEqual(2, mon2.Testhashu32Fnv1())
-        self.assertEqual(3, mon2.Testhashs64Fnv1())
-        self.assertEqual(4, mon2.Testhashu64Fnv1())
-        self.assertEqual(5, mon2.Testhashs32Fnv1a())
-        self.assertEqual(6, mon2.Testhashu32Fnv1a())
-        self.assertEqual(7, mon2.Testhashs64Fnv1a())
-        self.assertEqual(8, mon2.Testhashu64Fnv1a())
+  def test_nondefault_monster_testhashes(self):
+    b = flatbuffers.Builder(0)
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddTesthashs32Fnv1(b, 1)
+    _MONSTER.MonsterAddTesthashu32Fnv1(b, 2)
+    _MONSTER.MonsterAddTesthashs64Fnv1(b, 3)
+    _MONSTER.MonsterAddTesthashu64Fnv1(b, 4)
+    _MONSTER.MonsterAddTesthashs32Fnv1a(b, 5)
+    _MONSTER.MonsterAddTesthashu32Fnv1a(b, 6)
+    _MONSTER.MonsterAddTesthashs64Fnv1a(b, 7)
+    _MONSTER.MonsterAddTesthashu64Fnv1a(b, 8)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_default_monster_parent_namespace_test(self):
-        self.assertEqual(None, self.mon.ParentNamespaceTest())
+    # inspect the resulting data:
+    mon2 = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertEqual(1, mon2.Testhashs32Fnv1())
+    self.assertEqual(2, mon2.Testhashu32Fnv1())
+    self.assertEqual(3, mon2.Testhashs64Fnv1())
+    self.assertEqual(4, mon2.Testhashu64Fnv1())
+    self.assertEqual(5, mon2.Testhashs32Fnv1a())
+    self.assertEqual(6, mon2.Testhashu32Fnv1a())
+    self.assertEqual(7, mon2.Testhashs64Fnv1a())
+    self.assertEqual(8, mon2.Testhashu64Fnv1a())
 
-    def test_nondefault_monster_parent_namespace_test(self):
-        b = flatbuffers.Builder(0)
-        MyGame.InParentNamespace.Start(b)
-        parent = MyGame.InParentNamespace.End(b)
-        MyGame.Example.Monster.Start(b)
-        MyGame.Example.Monster.AddParentNamespaceTest(b, parent)
-        mon = MyGame.Example.Monster.End(b)
-        b.Finish(mon)
+  def test_default_monster_parent_namespace_test(self):
+    self.assertEqual(None, self.mon.ParentNamespaceTest())
 
-        # Inspect the resulting data.
-        monster = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
-                                                                  b.Head())
-        self.assertTrue(isinstance(monster.ParentNamespaceTest(),
-                                   MyGame.InParentNamespace.InParentNamespace))
+  def test_nondefault_monster_parent_namespace_test(self):
+    b = flatbuffers.Builder(0)
+    _IN_PARENT_NAMESPACE.InParentNamespaceStart(b)
+    parent = _IN_PARENT_NAMESPACE.InParentNamespaceEnd(b)
+    _MONSTER.MonsterStart(b)
+    _MONSTER.MonsterAddParentNamespaceTest(b, parent)
+    mon = _MONSTER.MonsterEnd(b)
+    b.Finish(mon)
 
-    def test_getrootas_for_nonroot_table(self):
-        b = flatbuffers.Builder(0)
-        string = b.CreateString("MyStat")
+    # Inspect the resulting data.
+    monster = _MONSTER.Monster.GetRootAs(b.Bytes, b.Head())
+    self.assertTrue(
+        isinstance(monster.ParentNamespaceTest(),
+                   _IN_PARENT_NAMESPACE.InParentNamespace))
 
-        MyGame.Example.Stat.Start(b)
-        MyGame.Example.Stat.AddId(b, string)
-        MyGame.Example.Stat.AddVal(b, 12345678)
-        MyGame.Example.Stat.AddCount(b, 12345)
-        stat = MyGame.Example.Stat.End(b)
-        b.Finish(stat)
+  def test_getrootas_for_nonroot_table(self):
+    b = flatbuffers.Builder(0)
+    string = b.CreateString('MyStat')
 
-        stat2 = MyGame.Example.Stat.Stat.GetRootAs(b.Bytes, b.Head())
+    _STAT.StatStart(b)
+    _STAT.StatAddId(b, string)
+    _STAT.StatAddVal(b, 12345678)
+    _STAT.StatAddCount(b, 12345)
+    stat = _STAT.StatEnd(b)
+    b.Finish(stat)
 
-        self.assertEqual(b"MyStat", stat2.Id())
-        self.assertEqual(12345678, stat2.Val())
-        self.assertEqual(12345, stat2.Count())
+    stat2 = _STAT.Stat.GetRootAs(b.Bytes, b.Head())
+
+    self.assertEqual(b'MyStat', stat2.Id())
+    self.assertEqual(12345678, stat2.Val())
+    self.assertEqual(12345, stat2.Count())
 
 
 class TestAllCodePathsOfMonsterExtraSchema(unittest.TestCase):
-    def setUp(self, *args, **kwargs):
-        super(TestAllCodePathsOfMonsterExtraSchema, self).setUp(*args, **kwargs)
 
-        b = flatbuffers.Builder(0)
-        MyGame.MonsterExtra.Start(b)
-        gen_mon = MyGame.MonsterExtra.End(b)
-        b.Finish(gen_mon)
+  def setUp(self, *args, **kwargs):
+    super(TestAllCodePathsOfMonsterExtraSchema, self).setUp(*args, **kwargs)
 
-        self.mon = MyGame.MonsterExtra.MonsterExtra.GetRootAs(b.Bytes, b.Head())
+    b = flatbuffers.Builder(0)
+    MyGame.MonsterExtra.Start(b)
+    gen_mon = MyGame.MonsterExtra.End(b)
+    b.Finish(gen_mon)
 
-    def test_default_nan_inf(self):
-        self.assertTrue(math.isnan(self.mon.F1()))
-        self.assertEqual(self.mon.F2(), float("inf"))
-        self.assertEqual(self.mon.F3(), float("-inf"))
+    self.mon = MyGame.MonsterExtra.MonsterExtra.GetRootAs(b.Bytes, b.Head())
 
-        self.assertTrue(math.isnan(self.mon.D1()))
-        self.assertEqual(self.mon.D2(), float("inf"))
-        self.assertEqual(self.mon.D3(), float("-inf"))
+  def test_default_nan_inf(self):
+    self.assertTrue(math.isnan(self.mon.F1()))
+    self.assertEqual(self.mon.F2(), float('inf'))
+    self.assertEqual(self.mon.F3(), float('-inf'))
+
+    self.assertTrue(math.isnan(self.mon.D1()))
+    self.assertEqual(self.mon.D2(), float('inf'))
+    self.assertEqual(self.mon.D3(), float('-inf'))
 
 
 class TestVtableDeduplication(unittest.TestCase):
-    ''' TestVtableDeduplication verifies that vtables are deduplicated. '''
+  """ TestVtableDeduplication verifies that vtables are deduplicated. """
 
-    def test_vtable_deduplication(self):
-        b = flatbuffers.Builder(0)
+  def test_vtable_deduplication(self):
+    b = flatbuffers.Builder(0)
 
-        b.StartObject(4)
-        b.PrependByteSlot(0, 0, 0)
-        b.PrependByteSlot(1, 11, 0)
-        b.PrependByteSlot(2, 22, 0)
-        b.PrependInt16Slot(3, 33, 0)
-        obj0 = b.EndObject()
+    b.StartObject(4)
+    b.PrependByteSlot(0, 0, 0)
+    b.PrependByteSlot(1, 11, 0)
+    b.PrependByteSlot(2, 22, 0)
+    b.PrependInt16Slot(3, 33, 0)
+    obj0 = b.EndObject()
 
-        b.StartObject(4)
-        b.PrependByteSlot(0, 0, 0)
-        b.PrependByteSlot(1, 44, 0)
-        b.PrependByteSlot(2, 55, 0)
-        b.PrependInt16Slot(3, 66, 0)
-        obj1 = b.EndObject()
+    b.StartObject(4)
+    b.PrependByteSlot(0, 0, 0)
+    b.PrependByteSlot(1, 44, 0)
+    b.PrependByteSlot(2, 55, 0)
+    b.PrependInt16Slot(3, 66, 0)
+    obj1 = b.EndObject()
 
-        b.StartObject(4)
-        b.PrependByteSlot(0, 0, 0)
-        b.PrependByteSlot(1, 77, 0)
-        b.PrependByteSlot(2, 88, 0)
-        b.PrependInt16Slot(3, 99, 0)
-        obj2 = b.EndObject()
+    b.StartObject(4)
+    b.PrependByteSlot(0, 0, 0)
+    b.PrependByteSlot(1, 77, 0)
+    b.PrependByteSlot(2, 88, 0)
+    b.PrependInt16Slot(3, 99, 0)
+    obj2 = b.EndObject()
 
-        got = b.Bytes[b.Head():]
+    got = b.Bytes[b.Head():]
 
-        want = bytearray([
-            240, 255, 255, 255,  # == -12. offset to dedupped vtable.
-            99, 0,
-            88,
-            77,
-            248, 255, 255, 255,  # == -8. offset to dedupped vtable.
-            66, 0,
-            55,
-            44,
-            12, 0,
-            8, 0,
-            0, 0,
-            7, 0,
-            6, 0,
-            4, 0,
-            12, 0, 0, 0,
-            33, 0,
-            22,
-            11,
-        ])
+    want = bytearray([
+        240,
+        255,
+        255,
+        255,  # == -12. offset to dedupped vtable.
+        99,
+        0,
+        88,
+        77,
+        248,
+        255,
+        255,
+        255,  # == -8. offset to dedupped vtable.
+        66,
+        0,
+        55,
+        44,
+        12,
+        0,
+        8,
+        0,
+        0,
+        0,
+        7,
+        0,
+        6,
+        0,
+        4,
+        0,
+        12,
+        0,
+        0,
+        0,
+        33,
+        0,
+        22,
+        11,
+    ])
 
-        self.assertEqual((len(want), want), (len(got), got))
+    self.assertEqual((len(want), want), (len(got), got))
 
-        table0 = flatbuffers.table.Table(b.Bytes, len(b.Bytes) - obj0)
-        table1 = flatbuffers.table.Table(b.Bytes, len(b.Bytes) - obj1)
-        table2 = flatbuffers.table.Table(b.Bytes, len(b.Bytes) - obj2)
+    table0 = flatbuffers.table.Table(b.Bytes, len(b.Bytes) - obj0)
+    table1 = flatbuffers.table.Table(b.Bytes, len(b.Bytes) - obj1)
+    table2 = flatbuffers.table.Table(b.Bytes, len(b.Bytes) - obj2)
 
-        def _checkTable(tab, voffsett_value, b, c, d):
-            # vtable size
-            got = tab.GetVOffsetTSlot(0, 0)
-            self.assertEqual(12, got, 'case 0, 0')
+    def _checkTable(tab, voffsett_value, b, c, d):
+      # vtable size
+      got = tab.GetVOffsetTSlot(0, 0)
+      self.assertEqual(12, got, 'case 0, 0')
 
-            # object size
-            got = tab.GetVOffsetTSlot(2, 0)
-            self.assertEqual(8, got, 'case 2, 0')
+      # object size
+      got = tab.GetVOffsetTSlot(2, 0)
+      self.assertEqual(8, got, 'case 2, 0')
 
-            # default value
-            got = tab.GetVOffsetTSlot(4, 0)
-            self.assertEqual(voffsett_value, got, 'case 4, 0')
+      # default value
+      got = tab.GetVOffsetTSlot(4, 0)
+      self.assertEqual(voffsett_value, got, 'case 4, 0')
 
-            got = tab.GetSlot(6, 0, N.Uint8Flags)
-            self.assertEqual(b, got, 'case 6, 0')
+      got = tab.GetSlot(6, 0, N.Uint8Flags)
+      self.assertEqual(b, got, 'case 6, 0')
 
-            val = tab.GetSlot(8, 0, N.Uint8Flags)
-            self.assertEqual(c, val, 'failed 8, 0')
+      val = tab.GetSlot(8, 0, N.Uint8Flags)
+      self.assertEqual(c, val, 'failed 8, 0')
 
-            got = tab.GetSlot(10, 0, N.Uint8Flags)
-            self.assertEqual(d, got, 'failed 10, 0')
+      got = tab.GetSlot(10, 0, N.Uint8Flags)
+      self.assertEqual(d, got, 'failed 10, 0')
 
-        _checkTable(table0, 0, 11, 22, 33)
-        _checkTable(table1, 0, 44, 55, 66)
-        _checkTable(table2, 0, 77, 88, 99)
+    _checkTable(table0, 0, 11, 22, 33)
+    _checkTable(table1, 0, 44, 55, 66)
+    _checkTable(table2, 0, 77, 88, 99)
 
 
 class TestExceptions(unittest.TestCase):
-    def test_object_is_nested_error(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(0)
-        assertRaises(self, lambda: b.StartObject(0),
-                     flatbuffers.builder.IsNestedError)
 
-    def test_object_is_not_nested_error(self):
-        b = flatbuffers.Builder(0)
-        assertRaises(self, lambda: b.EndObject(),
-                     flatbuffers.builder.IsNotNestedError)
+  def test_object_is_nested_error(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(0)
+    assertRaises(self, lambda: b.StartObject(0),
+                 flatbuffers.builder.IsNestedError)
 
-    def test_struct_is_not_inline_error(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(0)
-        assertRaises(self, lambda: b.PrependStructSlot(0, 1, 0),
-                     flatbuffers.builder.StructIsNotInlineError)
+  def test_object_is_not_nested_error(self):
+    b = flatbuffers.Builder(0)
+    assertRaises(self, lambda: b.EndObject(),
+                 flatbuffers.builder.IsNotNestedError)
 
-    def test_unreachable_error(self):
-        b = flatbuffers.Builder(0)
-        assertRaises(self, lambda: b.PrependUOffsetTRelative(1),
-                     flatbuffers.builder.OffsetArithmeticError)
+  def test_struct_is_not_inline_error(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(0)
+    assertRaises(self, lambda: b.PrependStructSlot(0, 1, 0),
+                 flatbuffers.builder.StructIsNotInlineError)
 
-    def test_create_string_is_nested_error(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(0)
-        s = 'test1'
-        assertRaises(self, lambda: b.CreateString(s),
-                     flatbuffers.builder.IsNestedError)
+  def test_unreachable_error(self):
+    b = flatbuffers.Builder(0)
+    assertRaises(self, lambda: b.PrependUOffsetTRelative(1),
+                 flatbuffers.builder.OffsetArithmeticError)
 
-    def test_create_byte_vector_is_nested_error(self):
-        b = flatbuffers.Builder(0)
-        b.StartObject(0)
-        s = b'test1'
-        assertRaises(self, lambda: b.CreateByteVector(s),
-                     flatbuffers.builder.IsNestedError)
+  def test_create_string_is_nested_error(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(0)
+    s = 'test1'
+    assertRaises(self, lambda: b.CreateString(s),
+                 flatbuffers.builder.IsNestedError)
 
-    def test_finished_bytes_error(self):
-        b = flatbuffers.Builder(0)
-        assertRaises(self, lambda: b.Output(),
-                     flatbuffers.builder.BuilderNotFinishedError)
+  def test_create_byte_vector_is_nested_error(self):
+    b = flatbuffers.Builder(0)
+    b.StartObject(0)
+    s = b'test1'
+    assertRaises(self, lambda: b.CreateByteVector(s),
+                 flatbuffers.builder.IsNestedError)
+
+  def test_finished_bytes_error(self):
+    b = flatbuffers.Builder(0)
+    assertRaises(self, lambda: b.Output(),
+                 flatbuffers.builder.BuilderNotFinishedError)
 
 
 class TestFixedLengthArrays(unittest.TestCase):
-    def test_fixed_length_array(self):
-        builder = flatbuffers.Builder(0)
 
-        a = 0.5
-        b = range(0, 15)
-        c = 1
-        d_a = [[1, 2], [3, 4]]
-        d_b = [MyGame.Example.TestEnum.TestEnum.B, \
-                MyGame.Example.TestEnum.TestEnum.C]
-        d_c = [[MyGame.Example.TestEnum.TestEnum.A, \
-                MyGame.Example.TestEnum.TestEnum.B], \
-                [MyGame.Example.TestEnum.TestEnum.C, \
-                 MyGame.Example.TestEnum.TestEnum.B]]
-        d_d = [[-1, 1], [-2, 2]]
-        e = 2
-        f = [-1, 1]
+  def test_fixed_length_array(self):
+    builder = flatbuffers.Builder(0)
 
-        arrayOffset = MyGame.Example.ArrayStruct.CreateArrayStruct(builder, \
-            a, b, c, d_a, d_b, d_c, d_d, e, f)
-
-        # Create a table with the ArrayStruct.
-        MyGame.Example.ArrayTable.Start(builder)
-        MyGame.Example.ArrayTable.AddA(builder, arrayOffset)
-        tableOffset = MyGame.Example.ArrayTable.End(builder)
-
-        builder.Finish(tableOffset)
-
-        buf = builder.Output()
-
-        table = MyGame.Example.ArrayTable.ArrayTable.GetRootAs(buf)
-
-        # Verify structure.
-        nested = MyGame.Example.NestedStruct.NestedStruct()
-        self.assertEqual(table.A().A(), 0.5)
-        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(), \
-            MyGame.Example.TestEnum.TestEnum.B)
-        self.assertEqual(table.A().D(nested, 1).B(), \
-            MyGame.Example.TestEnum.TestEnum.C)
-        self.assertEqual(table.A().D(nested, 0).C(), \
-            [MyGame.Example.TestEnum.TestEnum.A, \
-             MyGame.Example.TestEnum.TestEnum.B])
-        self.assertEqual(table.A().D(nested, 1).C(), \
+    a = 0.5
+    b = range(0, 15)
+    c = 1
+    d_a = [[1, 2], [3, 4]]
+    d_b = [MyGame.Example.TestEnum.TestEnum.B, \
+            MyGame.Example.TestEnum.TestEnum.C]
+    d_c = [[MyGame.Example.TestEnum.TestEnum.A, \
+            MyGame.Example.TestEnum.TestEnum.B], \
             [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().E(), 2)
-        self.assertEqual(table.A().F(), [-1, 1])
+             MyGame.Example.TestEnum.TestEnum.B]]
+    d_d = [[-1, 1], [-2, 2]]
+    e = 2
+    f = [-1, 1]
+
+    arrayOffset = MyGame.Example.ArrayStruct.CreateArrayStruct(builder, \
+        a, b, c, d_a, d_b, d_c, d_d, e, f)
+
+    # Create a table with the ArrayStruct.
+    MyGame.Example.ArrayTable.Start(builder)
+    MyGame.Example.ArrayTable.AddA(builder, arrayOffset)
+    tableOffset = MyGame.Example.ArrayTable.End(builder)
+
+    builder.Finish(tableOffset)
+
+    buf = builder.Output()
+
+    table = MyGame.Example.ArrayTable.ArrayTable.GetRootAs(buf)
+
+    # Verify structure.
+    nested = MyGame.Example.NestedStruct.NestedStruct()
+    self.assertEqual(table.A().A(), 0.5)
+    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(), \
+        MyGame.Example.TestEnum.TestEnum.B)
+    self.assertEqual(table.A().D(nested, 1).B(), \
+        MyGame.Example.TestEnum.TestEnum.C)
+    self.assertEqual(table.A().D(nested, 0).C(), \
+        [MyGame.Example.TestEnum.TestEnum.A, \
+         MyGame.Example.TestEnum.TestEnum.B])
+    self.assertEqual(table.A().D(nested, 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().E(), 2)
+    self.assertEqual(table.A().F(), [-1, 1])
 
 
 def CheckAgainstGoldDataGo():
-    try:
-        gen_buf, gen_off = make_monster_from_generated_code()
-        fn = 'monsterdata_go_wire.mon'
-        if not os.path.exists(fn):
-            print('Go-generated data does not exist, failed.')
-            return False
+  try:
+    gen_buf, gen_off = make_monster_from_generated_code()
+    fn = 'monsterdata_go_wire.mon'
+    if not os.path.exists(fn):
+      print('Go-generated data does not exist, failed.')
+      return False
 
-        # would like to use a context manager here, but it's less
-        # backwards-compatible:
-        f = open(fn, 'rb')
-        go_wire_data = f.read()
-        f.close()
+    # would like to use a context manager here, but it's less
+    # backwards-compatible:
+    f = open(fn, 'rb')
+    go_wire_data = f.read()
+    f.close()
 
-        CheckReadBuffer(bytearray(go_wire_data), 0)
-        if not bytearray(gen_buf[gen_off:]) == bytearray(go_wire_data):
-            raise AssertionError('CheckAgainstGoldDataGo failed')
-    except:
-        print('Failed to test against Go-generated test data.')
-        return False
+    CheckReadBuffer(bytearray(go_wire_data), 0)
+    if not bytearray(gen_buf[gen_off:]) == bytearray(go_wire_data):
+      raise AssertionError('CheckAgainstGoldDataGo failed')
+  except:
+    print('Failed to test against Go-generated test data.')
+    return False
 
-    print('Can read Go-generated test data, and Python generates bytewise identical data.')
-    return True
+  print(
+      'Can read Go-generated test data, and Python generates bytewise identical data.'
+  )
+  return True
 
 
 def CheckAgainstGoldDataJava():
-    try:
-        gen_buf, gen_off = make_monster_from_generated_code()
-        fn = 'monsterdata_java_wire.mon'
-        if not os.path.exists(fn):
-            print('Java-generated data does not exist, failed.')
-            return False
-        f = open(fn, 'rb')
-        java_wire_data = f.read()
-        f.close()
+  try:
+    gen_buf, gen_off = make_monster_from_generated_code()
+    fn = 'monsterdata_java_wire.mon'
+    if not os.path.exists(fn):
+      print('Java-generated data does not exist, failed.')
+      return False
+    f = open(fn, 'rb')
+    java_wire_data = f.read()
+    f.close()
 
-        CheckReadBuffer(bytearray(java_wire_data), 0)
-    except:
-        print('Failed to read Java-generated test data.')
-        return False
+    CheckReadBuffer(bytearray(java_wire_data), 0)
+  except:
+    print('Failed to read Java-generated test data.')
+    return False
 
-    print('Can read Java-generated test data.')
-    return True
+  print('Can read Java-generated test data.')
+  return True
 
 
 class LCG(object):
-    ''' Include simple random number generator to ensure results will be the
+  """ Include simple random number generator to ensure results will be the
+
         same cross platform.
-        http://en.wikipedia.org/wiki/Park%E2%80%93Miller_random_number_generator '''
+        http://en.wikipedia.org/wiki/Park%E2%80%93Miller_random_number_generator
+        """
 
-    __slots__ = ['n']
+  __slots__ = ['n']
 
-    InitialLCGSeed = 48271
+  InitialLCGSeed = 48271
 
-    def __init__(self):
-        self.n = self.InitialLCGSeed
+  def __init__(self):
+    self.n = self.InitialLCGSeed
 
-    def Reset(self):
-        self.n = self.InitialLCGSeed
+  def Reset(self):
+    self.n = self.InitialLCGSeed
 
-    def Next(self):
-        self.n = ((self.n * 279470273) % 4294967291) & 0xFFFFFFFF
-        return self.n
+  def Next(self):
+    self.n = ((self.n * 279470273) % 4294967291) & 0xFFFFFFFF
+    return self.n
 
 
 def BenchmarkVtableDeduplication(count):
-    '''
+  """
     BenchmarkVtableDeduplication measures the speed of vtable deduplication
     by creating `prePop` vtables, then populating `count` objects with a
     different single vtable.
 
     When count is large (as in long benchmarks), memory usage may be high.
-    '''
+    """
 
-    for prePop in (1, 10, 100, 1000):
-        builder = flatbuffers.Builder(0)
-        n = 1 + int(math.log(prePop, 1.5))
+  for prePop in (1, 10, 100, 1000):
+    builder = flatbuffers.Builder(0)
+    n = 1 + int(math.log(prePop, 1.5))
 
-        # generate some layouts:
-        layouts = set()
-        r = list(compat_range(n))
-        while len(layouts) < prePop:
-            layouts.add(tuple(sorted(random.sample(r, int(max(1, n / 2))))))
+    # generate some layouts:
+    layouts = set()
+    r = list(compat_range(n))
+    while len(layouts) < prePop:
+      layouts.add(tuple(sorted(random.sample(r, int(max(1, n / 2))))))
 
-        layouts = list(layouts)
+    layouts = list(layouts)
 
-        # pre-populate vtables:
-        for layout in layouts:
-            builder.StartObject(n)
-            for j in layout:
-                builder.PrependInt16Slot(j, j, 0)
-            builder.EndObject()
-
-        # benchmark deduplication of a new vtable:
-        def f():
-            layout = random.choice(layouts)
-            builder.StartObject(n)
-            for j in layout:
-                builder.PrependInt16Slot(j, j, 0)
-            builder.EndObject()
-
-        duration = timeit.timeit(stmt=f, number=count)
-        rate = float(count) / duration
-        print(('vtable deduplication rate (n=%d, vtables=%d): %.2f sec' % (
-            prePop,
-            len(builder.vtables),
-            rate))
-        )
-
-
-def BenchmarkCheckReadBuffer(count, buf, off):
-    '''
-    BenchmarkCheckReadBuffer measures the speed of flatbuffer reading
-    by re-using the CheckReadBuffer function with the gold data.
-    '''
+    # pre-populate vtables:
+    for layout in layouts:
+      builder.StartObject(n)
+      for j in layout:
+        builder.PrependInt16Slot(j, j, 0)
+      builder.EndObject()
 
+    # benchmark deduplication of a new vtable:
     def f():
-        CheckReadBuffer(buf, off)
+      layout = random.choice(layouts)
+      builder.StartObject(n)
+      for j in layout:
+        builder.PrependInt16Slot(j, j, 0)
+      builder.EndObject()
 
     duration = timeit.timeit(stmt=f, number=count)
     rate = float(count) / duration
-    data = float(len(buf) * count) / float(1024 * 1024)
-    data_rate = data / float(duration)
+    print(('vtable deduplication rate (n=%d, vtables=%d): %.2f sec' %
+           (prePop, len(builder.vtables), rate)))
 
-    print(('traversed %d %d-byte flatbuffers in %.2fsec: %.2f/sec, %.2fMB/sec')
-          % (count, len(buf), duration, rate, data_rate))
+
+def BenchmarkCheckReadBuffer(count, buf, off):
+  """
+    BenchmarkCheckReadBuffer measures the speed of flatbuffer reading
+    by re-using the CheckReadBuffer function with the gold data.
+    """
+
+  def f():
+    CheckReadBuffer(buf, off)
+
+  duration = timeit.timeit(stmt=f, number=count)
+  rate = float(count) / duration
+  data = float(len(buf) * count) / float(1024 * 1024)
+  data_rate = data / float(duration)
+
+  print(('traversed %d %d-byte flatbuffers in %.2fsec: %.2f/sec, %.2fMB/sec') %
+        (count, len(buf), duration, rate, data_rate))
 
 
 def BenchmarkMakeMonsterFromGeneratedCode(count, length):
-    '''
+  """
     BenchmarkMakeMonsterFromGeneratedCode measures the speed of flatbuffer
     creation by re-using the make_monster_from_generated_code function for
     generating gold data examples.
-    '''
+    """
 
-    duration = timeit.timeit(stmt=make_monster_from_generated_code,
-                             number=count)
-    rate = float(count) / duration
-    data = float(length * count) / float(1024 * 1024)
-    data_rate = data / float(duration)
+  duration = timeit.timeit(stmt=make_monster_from_generated_code, number=count)
+  rate = float(count) / duration
+  data = float(length * count) / float(1024 * 1024)
+  data_rate = data / float(duration)
 
-    print(('built %d %d-byte flatbuffers in %.2fsec: %.2f/sec, %.2fMB/sec' % \
-           (count, length, duration, rate, data_rate)))
+  print(('built %d %d-byte flatbuffers in %.2fsec: %.2f/sec, %.2fMB/sec' % \
+         (count, length, duration, rate, data_rate)))
 
 
 def backward_compatible_run_tests(**kwargs):
-    if PY_VERSION < (2, 6):
-        sys.stderr.write("Python version less than 2.6 are not supported")
-        sys.stderr.flush()
+  if PY_VERSION < (2, 6):
+    sys.stderr.write('Python version less than 2.6 are not supported')
+    sys.stderr.flush()
+    return False
+
+  # python2.6 has a reduced-functionality unittest.main function:
+  if PY_VERSION == (2, 6):
+    try:
+      unittest.main(**kwargs)
+    except SystemExit as e:
+      if not e.code == 0:
         return False
-
-    # python2.6 has a reduced-functionality unittest.main function:
-    if PY_VERSION == (2, 6):
-        try:
-            unittest.main(**kwargs)
-        except SystemExit as e:
-            if not e.code == 0:
-                return False
-        return True
-
-    # python2.7 and above let us not exit once unittest.main is run:
-    kwargs['exit'] = False
-    kwargs['verbosity'] = 0
-    ret = unittest.main(**kwargs)
-    if ret.result.errors or ret.result.failures:
-        return False
-
     return True
 
+  # python2.7 and above let us not exit once unittest.main is run:
+  kwargs['exit'] = False
+  kwargs['verbosity'] = 0
+  ret = unittest.main(**kwargs)
+  if ret.result.errors or ret.result.failures:
+    return False
+
+  return True
+
+
 def main():
-    import os
-    import sys
-    if not len(sys.argv) == 4:
-       sys.stderr.write('Usage: %s <benchmark vtable count>'
-                        '<benchmark read count> <benchmark build count>\n'
-                        % sys.argv[0])
-       sys.stderr.write('       Provide COMPARE_GENERATED_TO_GO=1   to check'
-                        'for bytewise comparison to Go data.\n')
-       sys.stderr.write('       Provide COMPARE_GENERATED_TO_JAVA=1 to check'
-                        'for bytewise comparison to Java data.\n')
-       sys.stderr.flush()
-       sys.exit(1)
+  import os
+  import sys
+  if not len(sys.argv) == 5:
+    sys.stderr.write('Usage: %s <benchmark vtable count> '
+                     '<benchmark read count> <benchmark build count> '
+                     '<is_onefile>\n' % sys.argv[0])
+    sys.stderr.write('       Provide COMPARE_GENERATED_TO_GO=1   to check'
+                     'for bytewise comparison to Go data.\n')
+    sys.stderr.write('       Provide COMPARE_GENERATED_TO_JAVA=1 to check'
+                     'for bytewise comparison to Java data.\n')
+    sys.stderr.flush()
+    sys.exit(1)
 
-    kwargs = dict(argv=sys.argv[:-3])
+  kwargs = dict(argv=sys.argv[:-4])
 
-    # show whether numpy is present, as it changes the test logic:
-    try:
-        import numpy
-        print('numpy available')
-    except ImportError:
-        print('numpy not available')
+  create_namespace_shortcut(sys.argv[4].lower() == 'true')
 
-    # run tests, and run some language comparison checks if needed:
-    success = backward_compatible_run_tests(**kwargs)
-    if success and os.environ.get('COMPARE_GENERATED_TO_GO', 0) == "1":
-        success = success and CheckAgainstGoldDataGo()
-    if success and os.environ.get('COMPARE_GENERATED_TO_JAVA', 0) == "1":
-        success = success and CheckAgainstGoldDataJava()
+  # show whether numpy is present, as it changes the test logic:
+  try:
+    import numpy
+    print('numpy available')
+  except ImportError:
+    print('numpy not available')
 
-    if not success:
-        sys.stderr.write('Tests failed, skipping benchmarks.\n')
-        sys.stderr.flush()
-        sys.exit(1)
+  # run tests, and run some language comparison checks if needed:
+  success = backward_compatible_run_tests(**kwargs)
+  if success and os.environ.get('COMPARE_GENERATED_TO_GO', 0) == '1':
+    success = success and CheckAgainstGoldDataGo()
+  if success and os.environ.get('COMPARE_GENERATED_TO_JAVA', 0) == '1':
+    success = success and CheckAgainstGoldDataJava()
+
+  if not success:
+    sys.stderr.write('Tests failed, skipping benchmarks.\n')
+    sys.stderr.flush()
+    sys.exit(1)
+
+  # run benchmarks (if 0, they will be a noop):
+  bench_vtable = int(sys.argv[1])
+  bench_traverse = int(sys.argv[2])
+  bench_build = int(sys.argv[3])
+  if bench_vtable:
+    BenchmarkVtableDeduplication(bench_vtable)
+  if bench_traverse:
+    buf, off = make_monster_from_generated_code()
+    BenchmarkCheckReadBuffer(bench_traverse, buf, off)
+  if bench_build:
+    buf, off = make_monster_from_generated_code()
+    BenchmarkMakeMonsterFromGeneratedCode(bench_build, len(buf))
 
-    # run benchmarks (if 0, they will be a noop):
-    bench_vtable = int(sys.argv[1])
-    bench_traverse = int(sys.argv[2])
-    bench_build = int(sys.argv[3])
-    if bench_vtable:
-        BenchmarkVtableDeduplication(bench_vtable)
-    if bench_traverse:
-        buf, off = make_monster_from_generated_code()
-        BenchmarkCheckReadBuffer(bench_traverse, buf, off)
-    if bench_build:
-        buf, off = make_monster_from_generated_code()
-        BenchmarkMakeMonsterFromGeneratedCode(bench_build, len(buf))
 
 if __name__ == '__main__':
-    main()
+  main()