/*

* Copyright 2014 Google Inc. All rights reserved.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

// independent from idl_parser, since this code is not needed for most clients

#include "idl_gen_python.h"

#include <algorithm>

#include <cstddef>

#include <cstdint>

#include <cstdio>

#include <map>

#include <set>

#include <sstream>

#include <string>

#include <utility>

#include <vector>

#include "codegen/idl_namer.h"

#include "codegen/python.h"

#include "flatbuffers/code_generators.h"

#include "flatbuffers/flatbuffers.h"

#include "flatbuffers/idl.h"

#include "flatbuffers/util.h"

namespace flatbuffers {

namespace python {

namespace {

typedef std::pair<std::string, std::string> ImportMapEntry;

typedef std::set<ImportMapEntry> ImportMap;

// Hardcode spaces per indentation.

static const CommentConfig def_comment = {nullptr, "#", nullptr};

static const std::string Indent = " ";

class PythonStubGenerator {

public:

PythonStubGenerator(const Parser& parser, const std::string& path,

const Version& version)

: parser_{parser},

namer_{WithFlagOptions(kStubConfig, parser.opts, path),

Keywords(version)},

version_(version) {}

bool Generate() {

if (parser_.opts.one_file) {

Imports imports;

std::stringstream stub;

DeclareUOffset(stub, &imports);

for (const EnumDef* def : parser_.enums_.vec) {

if (def->generated) continue;

GenerateEnumStub(stub, def, &imports);

}

for (const StructDef* def : parser_.structs_.vec) {

if (def->generated) continue;

GenerateStructStub(stub, def, &imports);

}

std::string filename =

namer_.config_.output_path +

StripPath(StripExtension(parser_.file_being_parsed_)) +

namer_.config_.filename_suffix + namer_.config_.filename_extension;

return SaveFile(filename, imports, stub);

}

for (const EnumDef* def : parser_.enums_.vec) {

if (def->generated) continue;

Imports imports;

std::stringstream stub;

DeclareUOffset(stub, &imports);

GenerateEnumStub(stub, def, &imports);

std::string filename = namer_.Directories(*def->defined_namespace) +

namer_.File(*def, SkipFile::Suffix);

if (!SaveFile(filename, imports, stub)) return false;

}

for (const StructDef* def : parser_.structs_.vec) {

if (def->generated) continue;

Imports imports;

std::stringstream stub;

DeclareUOffset(stub, &imports);

GenerateStructStub(stub, def, &imports);

std::string filename = namer_.Directories(*def->defined_namespace) +

namer_.File(*def, SkipFile::Suffix);

if (!SaveFile(filename, imports, stub)) return false;

}

return true;

}

private:

bool SaveFile(const std::string& filename, const Imports& imports,

const std::stringstream& content) {

std::stringstream ss;

GenerateImports(ss, imports);

ss << '\n';

ss << content.str() << '\n';

EnsureDirExists(StripFileName(filename));

return parser_.opts.file_saver->SaveFile(filename.c_str(), ss.str(), false);

}

static void DeclareUOffset(std::stringstream& stub, Imports* imports) {

imports->Import("flatbuffers");

imports->Import("typing");

stub << "uoffset: typing.TypeAlias = "

"flatbuffers.number_types.UOffsetTFlags.py_type\n"

<< '\n';

}

std::string ModuleForFile(const std::string& file) const {

if (parser_.file_being_parsed_ == file) return ".";

std::string module = parser_.opts.include_prefix + StripExtension(file) +

parser_.opts.filename_suffix;

std::replace(module.begin(), module.end(), '/', '.');

return module;

}

template <typename T>

std::string ModuleFor(const T* def) const {

if (parser_.opts.one_file) return ModuleForFile(def->file);

return namer_.NamespacedType(*def);

}

const StructDef* GetNestedStruct(const FieldDef* field) const {

const Value* nested = field->attributes.Lookup("nested_flatbuffer");

if (nested == nullptr) return nullptr;

StructDef* nested_def = parser_.LookupStruct(nested->constant);

if (nested_def != nullptr) return nested_def;

return parser_.LookupStruct(namer_.NamespacedType(

parser_.current_namespace_->components, nested->constant));

}

static std::string ScalarType(BaseType type) {

if (IsBool(type)) return "bool";

if (IsInteger(type)) return "int";

if (IsFloat(type)) return "float";

FLATBUFFERS_ASSERT(false);

return "None";

}

template <typename F>

std::string UnionType(const EnumDef& enum_def, Imports* imports,

F type) const {

imports->Import("typing");

std::string result = "";

for (const EnumVal* val : enum_def.Vals()) {

if (!result.empty()) result += ", ";

switch (val->union_type.base_type) {

case BASE_TYPE_STRUCT: {

Import import = imports->Import(ModuleFor(val->union_type.struct_def),

type(*val->union_type.struct_def));

result += import.name;

break;

}

case BASE_TYPE_STRING:

result += "str";

break;

case BASE_TYPE_NONE:

result += "None";

break;

default:

break;

}

}

return "typing.Union[" + result + "]";

}

std::string UnionObjectType(const EnumDef& enum_def, Imports* imports) const {

return UnionType(enum_def, imports, [this](const StructDef& struct_def) {

return namer_.ObjectType(struct_def);

});

}

std::string UnionType(const EnumDef& enum_def, Imports* imports) const {

return UnionType(enum_def, imports, [this](const StructDef& struct_def) {

return namer_.Type(struct_def);

});

}

std::string EnumType(const EnumDef& enum_def, Imports* imports) const {

imports->Import("typing");

const Import& import =

imports->Import(ModuleFor(&enum_def), namer_.Type(enum_def));

std::string result = "";

for (const EnumVal* val : enum_def.Vals()) {

if (!result.empty()) result += ", ";

result += import.name + "." + namer_.Variant(*val);

}

return "typing.Literal[" + result + "]";

}

std::string TypeOf(const Type& type, Imports* imports) const {

if (type.enum_def != nullptr) return EnumType(*type.enum_def, imports);

if (IsScalar(type.base_type)) return ScalarType(type.base_type);

switch (type.base_type) {

case BASE_TYPE_STRUCT: {

const Import& import = imports->Import(ModuleFor(type.struct_def),

namer_.Type(*type.struct_def));

return import.name;

}

case BASE_TYPE_STRING:

return "str";

case BASE_TYPE_ARRAY:

case BASE_TYPE_VECTOR: {

imports->Import("typing");

return "typing.List[" + TypeOf(type.VectorType(), imports) + "]";

}

case BASE_TYPE_UNION:

return UnionType(*type.enum_def, imports);

default:

FLATBUFFERS_ASSERT(0);

return "";

}

}

std::string GenerateObjectFieldStub(const FieldDef* field,

Imports* imports) const {

std::string field_name = namer_.Field(*field);

const Type& field_type = field->value.type;

if (IsScalar(field_type.base_type)) {

std::string result = field_name + ": " + TypeOf(field_type, imports);

if (field->IsOptional()) result += " | None";

return result;

}

switch (field_type.base_type) {

case BASE_TYPE_STRUCT: {

Import import =

imports->Import(ModuleFor(field_type.struct_def),

namer_.ObjectType(*field_type.struct_def));

return field_name + ": " + import.name + " | None";

}

case BASE_TYPE_STRING:

return field_name + ": str | None";

case BASE_TYPE_ARRAY:

case BASE_TYPE_VECTOR: {

imports->Import("typing");

if (field_type.element == BASE_TYPE_STRUCT) {

Import import =

imports->Import(ModuleFor(field_type.struct_def),

namer_.ObjectType(*field_type.struct_def));

return field_name + ": typing.List[" + import.name + "]";

}

if (field_type.element == BASE_TYPE_STRING) {

return field_name + ": typing.List[str]";

}

return field_name + ": typing.List[" +

TypeOf(field_type.VectorType(), imports) + "]";

}

case BASE_TYPE_UNION:

return field_name + ": " +

UnionObjectType(*field->value.type.enum_def, imports);

default:

return field_name;

}

}

void GenerateObjectInitializerStub(std::stringstream& stub,

const StructDef* struct_def,

Imports* imports) const {

stub << " def __init__(\n";

stub << " self,\n";

for (const FieldDef* field : struct_def->fields.vec) {

if (field->deprecated) continue;

std::string field_name = namer_.Field(*field);

std::string field_type;

const Type& type = field->value.type;

if (IsScalar(type.base_type)) {

field_type = TypeOf(type, imports);

if (field->IsOptional()) {

field_type += " | None";

}

} else {

switch (type.base_type) {

case BASE_TYPE_STRUCT: {

Import import_ =

imports->Import(ModuleFor(type.struct_def),

namer_.ObjectType(*type.struct_def));

field_type = "'" + import_.name + "' | None";

break;

}

case BASE_TYPE_STRING:

field_type = "str | None";

break;

case BASE_TYPE_ARRAY:

case BASE_TYPE_VECTOR: {

imports->Import("typing");

if (type.element == BASE_TYPE_STRUCT) {

Import import_ =

imports->Import(ModuleFor(type.struct_def),

namer_.ObjectType(*type.struct_def));

field_type = "typing.List['" + import_.name + "'] | None";

} else if (type.element == BASE_TYPE_STRING) {

field_type = "typing.List[str] | None";

} else {

field_type = "typing.List[" + TypeOf(type.VectorType(), imports) +

"] | None";

}

break;

}

case BASE_TYPE_UNION:

field_type = UnionObjectType(*type.enum_def, imports);

break;

default:

field_type = "typing.Any";

break;

}

}

stub << " " << field_name << ": " << field_type << " = ...,\n";

}

stub << " ) -> None: ...\n";

}

void GenerateObjectStub(std::stringstream& stub, const StructDef* struct_def,

Imports* imports) const {

std::string name = namer_.ObjectType(*struct_def);

imports->Export(ModuleFor(struct_def), namer_.Type(*struct_def));

stub << "class " << name;

if (version_.major != 3) stub << "(object)";

stub << ":\n";

for (const FieldDef* field : struct_def->fields.vec) {

if (field->deprecated) continue;

stub << " " << GenerateObjectFieldStub(field, imports) << "\n";

}

GenerateObjectInitializerStub(stub, struct_def, imports);

stub << " @classmethod\n";

stub << " def InitFromBuf(cls, buf: bytes, pos: int) -> " << name

<< ": ...\n";

stub << " @classmethod\n";

stub << " def InitFromPackedBuf(cls, buf: bytes, pos: int = 0) -> " << name

<< ": ...\n";

const Import& import =

imports->Import(ModuleFor(struct_def), namer_.Type(*struct_def));

stub << " @classmethod\n";

stub << " def InitFromObj(cls, " << namer_.Variable(*struct_def)

<< ": " + import.name + ") -> " << name << ": ...\n";

stub << " def _UnPack(self, " << namer_.Variable(*struct_def) << ": "

<< import.name << ") -> None: ...\n";

stub << " def Pack(self, builder: flatbuffers.Builder) -> None: ...\n";

if (parser_.opts.gen_compare) {

stub << " def __eq__(self, other: " << name + ") -> bool: ...\n";

}

}

void GenerateStructStub(std::stringstream& stub, const StructDef* struct_def,

Imports* imports) const {

std::string type = namer_.Type(*struct_def);

imports->Export(ModuleFor(struct_def), namer_.Type(*struct_def));

stub << "class " << type;

if (version_.major != 3) stub << "(object)";

stub << ":\n";

if (struct_def->fixed) {

stub << " @classmethod\n";

stub << " def SizeOf(cls) -> int: ...\n\n";

} else {

stub << " @classmethod\n";

stub << " def GetRootAs(cls, buf: bytes, offset: int) -> " << type

<< ": ...\n";

if (!parser_.opts.python_no_type_prefix_suffix) {

stub << " @classmethod\n";

stub << " def GetRootAs" << type

<< "(cls, buf: bytes, offset: int) -> " << type << ": ...\n";

}

if (parser_.file_identifier_.length()) {

stub << " @classmethod\n";

stub << " def " << type

<< "BufferHasIdentifier(cls, buf: bytes, offset: int, "

"size_prefixed: bool) -> bool: ...\n";

}

}

stub << " def Init(self, buf: bytes, pos: int) -> None: ...\n";

for (const FieldDef* field : struct_def->fields.vec) {

if (field->deprecated) continue;

std::string name = namer_.Method(*field);

const Type& field_type = field->value.type;

if (IsScalar(field_type.base_type)) {

stub << " def " << name << "(self) -> " << TypeOf(field_type, imports);

if (field->IsOptional()) stub << " | None";

stub << ": ...\n";

} else {

switch (field_type.base_type) {

case BASE_TYPE_STRUCT: {

const Import& import =

imports->Import(ModuleFor(field_type.struct_def),

namer_.Type(*field_type.struct_def));

if (struct_def->fixed) {

stub << " def " << name << "(self, obj: " << import.name

<< ") -> " << import.name << ": ...\n";

} else {

stub << " def " << name + "(self) -> " << import.name

<< " | None: ...\n";

}

break;

}

case BASE_TYPE_STRING:

stub << " def " << name << "(self) -> str | None: ...\n";

break;

case BASE_TYPE_ARRAY:

case BASE_TYPE_VECTOR: {

switch (field_type.element) {

case BASE_TYPE_STRUCT: {

const Import& import =

imports->Import(ModuleFor(field_type.struct_def),

namer_.Type(*field_type.struct_def));

stub << " def " << name << "(self, i: int) -> " << import.name

<< " | None: ...\n";

break;

}

case BASE_TYPE_STRING:

stub << " def " << name << "(self, i: int) -> str: ...\n";

break;

default: // scalars

stub << " def " << name << "(self, i: int) -> "

<< TypeOf(field_type, imports) << ": ...\n";

if (parser_.opts.python_gen_numpy) {

stub << " def " << name

<< "AsNumpy(self) -> np.ndarray: ...\n";

}

const StructDef* nested_def = GetNestedStruct(field);

if (nested_def != nullptr) {

const Import& import = imports->Import(

ModuleFor(nested_def), namer_.Type(*nested_def));

stub << " def " << name + "NestedRoot(self) -> "

<< import.name << " | None: ...\n";

}

break;

}

stub << " def " << name << "Length(self) -> int: ...\n";

stub << " def " << name << "IsNone(self) -> bool: ...\n";

break;

}

case BASE_TYPE_UNION: {

imports->Import("flatbuffers", "table");

stub << " def " << name << "(self) -> table.Table | None: ...\n";

break;

}

default:

break;

}

}

}

if (parser_.opts.generate_object_based_api) {

GenerateObjectStub(stub, struct_def, imports);

}

if (struct_def->fixed) {

GenerateStructBuilderStub(stub, struct_def, imports);

} else {

GenerateTableBuilderStub(stub, struct_def, imports);

}

}

void StructBuilderArgs(const StructDef& struct_def, const std::string prefix,

Imports* imports,

std::vector<std::string>* args) const {

for (const FieldDef* field : struct_def.fields.vec) {

const Type type = IsArray(field->value.type)

? field->value.type.VectorType()

: field->value.type;

if (type.base_type == BASE_TYPE_STRUCT) {

StructBuilderArgs(*field->value.type.struct_def,

prefix + namer_.Field(*field) + "_", imports, args);

} else {

args->push_back(prefix + namer_.Field(*field) + ": " +

TypeOf(type, imports));

}

}

}

void GenerateStructBuilderStub(std::stringstream& stub,

const StructDef* struct_def,

Imports* imports) const {

imports->Import("flatbuffers");

std::vector<std::string> args;

StructBuilderArgs(*struct_def, "", imports, &args);

stub << '\n';

stub << "def Create" + namer_.Type(*struct_def)

<< "(builder: flatbuffers.Builder";

for (const std::string& arg : args) {

stub << ", " << arg;

}

stub << ") -> uoffset: ...\n";

}

void GenerateTableBuilderStub(std::stringstream& stub,

const StructDef* struct_def,

Imports* imports) const {

std::string type = namer_.Type(*struct_def);

/**************************** def TableStart ****************************/

stub << "def ";

if (!parser_.opts.python_no_type_prefix_suffix) stub << type;

stub << "Start(builder: flatbuffers.Builder) -> None: ...\n";

if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {

stub << "def Start(builder: flatbuffers.Builder) -> None: ...\n";

}

/************************** def TableAddField ***************************/

for (const FieldDef* field : struct_def->fields.vec) {

if (field->deprecated) continue;

stub << "def ";

if (!parser_.opts.python_no_type_prefix_suffix) stub << type;

stub << "Add" << namer_.Method(*field)

<< "(builder: flatbuffers.Builder, "

<< namer_.Variable(*field) + ": ";

if (IsScalar(field->value.type.base_type)) {

stub << TypeOf(field->value.type, imports);

} else if (IsArray(field->value.type)) {

stub << TypeOf(field->value.type.VectorType(), imports);

} else {

stub << "uoffset";

}

stub << ") -> None: ...\n";

if (IsVector(field->value.type)) {

stub << "def ";

if (!parser_.opts.python_no_type_prefix_suffix) stub << type;

stub << "Start" << namer_.Method(*field)

<< "Vector(builder: flatbuffers.Builder, num_elems: int) -> "

"uoffset: ...\n";

if (!parser_.opts.one_file &&

!parser_.opts.python_no_type_prefix_suffix) {

stub << "def Start" << namer_.Method(*field)

<< "Vector(builder: flatbuffers.Builder, num_elems: int) -> "

"uoffset: ...\n";

}

if (GetNestedStruct(field) != nullptr) {

stub << "def " << type << "Make" << namer_.Method(*field)

<< "VectorFromBytes(builder: flatbuffers.Builder, buf: "

"bytes) -> uoffset: ...\n";

if (!parser_.opts.one_file) {

stub << "def Make" << namer_.Method(*field)

<< "VectorFromBytes(builder: flatbuffers.Builder, buf: "

"bytes) -> uoffset: ...\n";

}

}

stub << "def ";

if (!parser_.opts.python_no_type_prefix_suffix) stub << type;

stub << "Create" << namer_.Method(*field)

<< "Vector(builder: flatbuffers.Builder, data: typing.Iterable["

"typing.Any]) -> uoffset: ...\n";

if (!parser_.opts.one_file &&

!parser_.opts.python_no_type_prefix_suffix) {

stub << "def Create" << namer_.Method(*field)

<< "Vector(builder: flatbuffers.Builder, data: "

"typing.Iterable[typing.Any]) -> uoffset: ...\n";

}

}

}

/***************************** def TableEnd *****************************/

stub << "def ";

if (!parser_.opts.python_no_type_prefix_suffix) stub << type;

stub << "End(builder: flatbuffers.Builder) -> uoffset: ...\n";

if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {

stub << "def End(builder: flatbuffers.Builder) -> uoffset: ...\n";

}

}

void GenerateEnumStub(std::stringstream& stub, const EnumDef* enum_def,

Imports* imports) const {

stub << "class " << namer_.Type(*enum_def);

imports->Export(ModuleFor(enum_def), namer_.Type(*enum_def));

imports->Import("typing", "cast");

if (version_.major == 3) {

imports->Import("enum", "IntEnum");

stub << "(IntEnum)";

} else {

stub << "(object)";

}

stub << ":\n";

for (const EnumVal* val : enum_def->Vals()) {

stub << " " << namer_.Variant(*val) << " = cast("

<< ScalarType(enum_def->underlying_type.base_type) << ", ...)\n";

}

if (parser_.opts.generate_object_based_api & enum_def->is_union) {

imports->Import("flatbuffers", "table");

stub << "def " << namer_.Function(*enum_def)

<< "Creator(union_type: " << EnumType(*enum_def, imports)

<< ", table: table.Table) -> " << UnionType(*enum_def, imports)

<< ": ...\n";

}

}

void GenerateImports(std::stringstream& ss, const Imports& imports) {

ss << "from __future__ import annotations\n";

ss << '\n';

ss << "import flatbuffers\n";

if (parser_.opts.python_gen_numpy) {

ss << "import numpy as np\n";

}

ss << '\n';

std::set<std::string> modules;

std::map<std::string, std::set<std::string>> names_by_module;

for (const Import& import : imports.imports) {

if (import.IsLocal()) continue; // skip all local imports

if (import.module == "flatbuffers" && import.name == "")

continue; // skip double include hardcoded flatbuffers

if (import.name == "") {

modules.insert(import.module);

} else {

names_by_module[import.module].insert(import.name);

}

}

// Remove imports from exports

for (const Import& import : imports.exports) {

if (import.name == "") {

modules.erase(import.module);

} else {

auto search = names_by_module.find(import.module);

if (search != names_by_module.end()) {

search->second.erase(import.name);

}

}

}

for (const std::string& module : modules) {

ss << "import " << module << '\n';

}

for (const auto& import : names_by_module) {

if (!import.second.empty()) {

ss << "from " << import.first << " import ";

size_t i = 0;

for (const std::string& name : import.second) {

if (i > 0) ss << ", ";

ss << name;

++i;

}

ss << '\n';

}

}

}

const Parser& parser_;

const IdlNamer namer_;

const Version version_;

};

} // namespace

class PythonGenerator : public BaseGenerator {

public:

PythonGenerator(const Parser& parser, const std::string& path,

const std::string& file_name, const Version& version)

: BaseGenerator(parser, path, file_name, "" /* not used */,

"" /* not used */, "py"),

float_const_gen_("float('nan')", "float('inf')", "float('-inf')"),

namer_(WithFlagOptions(kConfig, parser.opts, path), Keywords(version)) {

}

// Most field accessors need to retrieve and test the field offset first,

// this is the prefix code for that.

std::string OffsetPrefix(const FieldDef& field, bool new_line = true) const {

return "\n" + Indent + Indent +

"o = flatbuffers.number_types.UOffsetTFlags.py_type" +

"(self._tab.Offset(" + NumToString(field.value.offset) + "))\n" +

Indent + Indent + "if o != 0:" + (new_line ? "\n" : "");

}

// Begin a class declaration.

void BeginClass(const StructDef& struct_def, std::string* code_ptr) const {

auto& code = *code_ptr;

code += "class " + namer_.Type(struct_def) + "(object):\n";

code += Indent + "__slots__ = ['_tab']";

code += "\n\n";

}

// Begin enum code with a class declaration.

void BeginEnum(const EnumDef& enum_def, std::string* code_ptr) const {

auto& code = *code_ptr;

code += "class " + namer_.Type(enum_def) + "(object):\n";

}

// Starts a new line and then indents.

std::string GenIndents(int num) const {

return "\n" + std::string(num * Indent.length(), ' ');

}

// A single enum member.

void EnumMember(const EnumDef& enum_def, const EnumVal& ev,

std::string* code_ptr) const {

auto& code = *code_ptr;

code += Indent;

code += namer_.Variant(ev);

code += " = ";

code += enum_def.ToString(ev) + "\n";

}

// Initialize a new struct or table from existing data.

void NewRootTypeFromBuffer(const StructDef& struct_def,

std::string* code_ptr) const {

auto& code = *code_ptr;

const std::string struct_type = namer_.Type(struct_def);

code += Indent + "@classmethod\n";

code += Indent + "def GetRootAs";

if (parser_.opts.python_typing) {

code += "(cls, buf, offset: int = 0):";

} else {

code += "(cls, buf, offset=0):";

}

code += "\n";

code += Indent + Indent;

code += "n = flatbuffers.encode.Get";

code += "(flatbuffers.packer.uoffset, buf, offset)\n";

code += Indent + Indent + "x = " + struct_type + "()\n";

code += Indent + Indent + "x.Init(buf, n + offset)\n";

code += Indent + Indent + "return x\n";

code += "\n";

if (!parser_.opts.python_no_type_prefix_suffix) {

// Add an alias with the old name

code += Indent + "@classmethod\n";

code +=

Indent + "def GetRootAs" + struct_type + "(cls, buf, offset=0):\n";

code += Indent + Indent +

"\"\"\"This method is deprecated. Please switch to "

"GetRootAs.\"\"\"\n";

code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n";

}

}

// Initialize an existing object with other data, to avoid an allocation.

void InitializeExisting(const StructDef& struct_def,

std::string* code_ptr) const {

auto& code = *code_ptr;

GenReceiver(struct_def, code_ptr);

if (parser_.opts.python_typing) {

code += "Init(self, buf: bytes, pos: int):\n";

} else {

code += "Init(self, buf, pos):\n";

}

code += Indent + Indent + "self._tab = flatbuffers.table.Table(buf, pos)\n";

code += "\n";

}

// Get the length of a vector.

void GetVectorLen(const StructDef& struct_def, const FieldDef& field,

std::string* code_ptr) const {

auto& code = *code_ptr;

GenReceiver(struct_def, code_ptr);

code += namer_.Method(field) + "Length(self)";

if (parser_.opts.python_typing) {

code += " -> int";

}

code += ":";

if (!IsArray(field.value.type)) {

code += OffsetPrefix(field, false);

code += GenIndents(3) + "return self._tab.VectorLen(o)";

code += GenIndents(2) + "return 0\n\n";

} else {

code += GenIndents(2) + "return " +

NumToString(field.value.type.fixed_length) + "\n\n";

}

}

// Determines whether a vector is none or not.

void GetVectorIsNone(const StructDef& struct_def, const FieldDef& field,

std::string* code_ptr) const {

auto& code = *code_ptr;

GenReceiver(struct_def, code_ptr);

code += namer_.Method(field) + "IsNone(self)";

if (parser_.opts.python_typing) {

code += " -> bool";

}

code += ":";

if (!IsArray(field.value.type)) {

code += GenIndents(2) +

"o = flatbuffers.number_types.UOffsetTFlags.py_type" +

"(self._tab.Offset(" + NumToString(field.value.offset) + "))";

code += GenIndents(2) + "return o == 0";

} else {

// assume that we always have an array as memory is preassigned

code += GenIndents(2) + "return False";

}

code += "\n\n";

}

// Get the value of a struct's scalar.

void GetScalarFieldOfStruct(const StructDef& struct_def,

const FieldDef& field,

std::string* code_ptr) const {

auto& code = *code_ptr;

std::string getter = GenGetter(field.value.type);

GenReceiver(struct_def, code_ptr);

code += namer_.Method(field);

code += "(self): return " + getter;

code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";

code += NumToString(field.value.offset) + "))\n";

}

// Get the value of a table's scalar.

void GetScalarFieldOfTable(const StructDef& struct_def, const FieldDef& field,

std::string* code_ptr) const {

auto& code = *code_ptr;

std::string getter = GenGetter(field.value.type);

GenReceiver(struct_def, code_ptr);

code += namer_.Method(field);

code += "(self):";

code += OffsetPrefix(field);

getter += "o + self._tab.Pos)";

auto is_bool = IsBool(field.value.type.base_type);

if (is_bool) {

getter = "bool(" + getter + ")";

}

code += Indent + Indent + Indent + "return " + getter + "\n";

std::string default_value;

if (field.IsScalarOptional()) {

default_value = "None";

} else if (is_bool) {

default_value = field.value.constant == "0" ? "False" : "True";

} else {

default_value = IsFloat(field.value.type.base_type)

? float_const_gen_.GenFloatConstant(field)

: field.value.constant;

}

code += Indent + Indent + "return " + default_value + "\n\n";

}

// Get a struct by initializing an existing struct.

// Specific to Struct.

void GetStructFieldOfStruct(const StructDef& struct_def,

const FieldDef& field,

std::string* code_ptr) const {

auto& code = *code_ptr;

GenReceiver(struct_def, code_ptr);

code += namer_.Method(field);

code += "(self, obj):\n";

code += Indent + Indent + "obj.Init(self._tab.Bytes, self._tab.Pos + ";

code += NumToString(field.value.offset) + ")";

code += "\n" + Indent + Indent + "return obj\n\n";

}

// Get the value of a fixed size array.

void GetArrayOfStruct(const StructDef& struct_def, const FieldDef& field,

std::string* code_ptr, ImportMap& imports) const {

auto& code = *code_ptr;

const auto vec_type = field.value.type.VectorType();

GenReceiver(struct_def, code_ptr);

code += namer_.Method(field);

const ImportMapEntry import_entry = {GenPackageReference(field.value.type),

TypeName(field)};

if (parser_.opts.python_typing) {

const std::string return_type = ReturnType(struct_def, field);

code += "(self, i: int)";

code += " -> " + return_type + ":";

imports.insert(import_entry);

} else {

code += "(self, i):";

}

if (parser_.opts.include_dependence_headers &&

!parser_.opts.python_typing) {

code += GenIndents(2);

code += "from " + import_entry.first + " import " + import_entry.second +

"\n";

}

code += GenIndents(2) + "obj = " + TypeName(field) + "()";

code += GenIndents(2) + "obj.Init(self._tab.Bytes, self._tab.Pos + ";

code += NumToString(field.value.offset) + " + i * ";

code += NumToString(InlineSize(vec_type));

code += ")" + GenIndents(2) + "return obj\n\n";

}

// Get the value of a vector's non-struct member. Uses a named return

// argument to conveniently set the zero value for the result.

void GetArrayOfNonStruct(const StructDef& struct_def, const FieldDef& field,

std::string* code_ptr) const {

auto& code = *code_ptr;

GenReceiver(struct_def, code_ptr);

code += namer_.Method(field);

code += "(self, j = None):";

code += GenIndents(2) + "if j is None:";

code += GenIndents(3) + "return [" + GenGetter(field.value.type);

code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";

code += NumToString(field.value.offset) + " + i * ";

code += NumToString(InlineSize(field.value.type.VectorType()));

code += ")) for i in range(";

code += "self." + namer_.Method(field) + "Length()" + ")]";

code += GenIndents(2) + "elif j >= 0 and j < self." + namer_.Method(field) +

"Length():";

code += GenIndents(3) + "return " + GenGetter(field.value.type);

code += "self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(";

code += NumToString(field.value.offset) + " + j * ";

code += NumToString(InlineSize(field.value.type.VectorType()));

code += "))";

code += GenIndents(2) + "else:";

code += GenIndents(3) + "return None\n\n";

}

// Get a struct by initializing an existing struct.

// Specific to Table.

void GetStructFieldOfTable(const StructDef& struct_def, const FieldDef& field,

std::string* code_ptr, ImportMap& imports) const {

auto& code = *code_ptr;

GenReceiver(struct_def, code_ptr);

code += namer_.Method(field) + "(self)";

const ImportMapEntry import_entry = {GenPackageReference(field.value.type),

TypeName(field)};

if (parser_.opts.python_typing) {

const std::string return_type = ReturnType(struct_def, field);

code += " -> Optional[" + return_type + "]";

imports.insert(ImportMapEntry{"typing", "Optional"});

imports.insert(import_entry);

}

code += ":";

code += OffsetPrefix(field);

if (field.value.type.struct_def->fixed) {

code += Indent + Indent + Indent + "x = o + self._tab.Pos\n";

} else {

code += Indent + Indent + Indent;

code += "x = self._tab.Indirect(o + self._tab.Pos)\n";

}

if (parser_.opts.include_dependence_headers &&

!parser_.opts.python_typing) {

code += Indent + Indent + Indent;

code += "from " + import_entry.first + " import " + import_entry.second +

"\n";

}

code += Indent + Indent + Indent + "obj = " + TypeName(field) + "()\n";

code += Indent + Indent + Indent + "obj.Init(self._tab.Bytes, x)\n";

code += Indent + Indent + Indent + "return obj\n";

code += Indent + Indent + "return None\n\n";

}