zlmdb.flatbuffers

Submodules

• zlmdb.flatbuffers._git_version
• zlmdb.flatbuffers.builder
• zlmdb.flatbuffers.compat
• zlmdb.flatbuffers.encode
• zlmdb.flatbuffers.flexbuffers
• zlmdb.flatbuffers.number_types
• zlmdb.flatbuffers.packer
• zlmdb.flatbuffers.reflection
• zlmdb.flatbuffers.table
• zlmdb.flatbuffers.util

Attributes

__git_version__

Classes

Builder	A Builder is used to construct one or more FlatBuffers.
Table	Table wraps a byte slice and provides read access to its data.

Functions

version(→ tuple[int, int, int, int | None, str | None])

Return the exact git version of the vendored FlatBuffers runtime.

Package Contents

class Builder(initialSize=1024)

Bases: object

A Builder is used to construct one or more FlatBuffers.

Typically, Builder objects will be used from code generated by the flatc compiler.

A Builder constructs byte buffers in a last-first manner for simplicity and performance during reading.

Internally, a Builder is a state machine for creating FlatBuffer objects.

It holds the following internal state:

• Bytes: an array of bytes.

• current_vtable: a list of integers.

• vtables: a hash of vtable entries.

Bytes

The internal bytearray for the Builder.

finished

A boolean determining if the Builder has been finalized.

Bytes

CreateByteVector(x)

CreateString writes a byte vector.

CreateNumpyVector(x)

CreateNumpyVector writes a numpy array into the buffer.

CreateString(s, encoding='utf-8', errors='strict')

CreateString writes a null-terminated byte string as a vector.

EndObject()

EndObject writes data necessary to finish object construction.

EndVector()

EndVector writes data necessary to finish vector construction.

Finish(rootTable, file_identifier=None)

Finish finalizes a buffer, pointing to the given rootTable.

FinishSizePrefixed(rootTable, file_identifier=None)

Finish finalizes a buffer, pointing to the given rootTable, with the size prefixed.

ForceDefaults(forceDefaults)

In order to save space, fields that are set to their default value don’t get serialized into the buffer. Forcing defaults provides a way to manually disable this optimization. When set to True, will always serialize default values.

Head()

Get the start of useful data in the underlying byte buffer.

Note: unlike other functions, this value is interpreted as from the left.

MAX_BUFFER_SIZE = 2147483648

Offset()

Offset relative to the end of the buffer.

Output()

Return the portion of the buffer that has been used for writing data.

This is the typical way to access the FlatBuffer data inside the builder. If you try to access Builder.Bytes directly, you would need to manually index it with Head(), since the buffer is constructed backwards.

It raises BuilderNotFinishedError if the buffer has not been finished with Finish.

Pad(n)

Pad places zeros at the current offset.

Place(x, flags)

Place prepends a value specified by flags to the Builder, without checking for available space.

PlaceSOffsetT(x)

PlaceSOffsetT prepends a SOffsetT to the Builder, without checking for space.

PlaceUOffsetT(x)

PlaceUOffsetT prepends a UOffsetT to the Builder, without checking for space.

PlaceVOffsetT(x)

PlaceVOffsetT prepends a VOffsetT to the Builder, without checking for space.

Prep(size, additionalBytes)

Prep prepares to write an element of size after additional_bytes have been written, e.g. if you write a string, you need to align such the int length field is aligned to SizeInt32, and the string data follows it directly. If all you need to do is align, additionalBytes will be 0.

Prepend(flags, off)

PrependBool(x)

Prepend a bool to the Builder buffer.

Note: aligns and checks for space.

PrependBoolSlot(*args)

PrependByte(x)

Prepend a byte to the Builder buffer.

Note: aligns and checks for space.

PrependByteSlot(*args)

PrependFloat32(x)

Prepend a float32 to the Builder buffer.

Note: aligns and checks for space.

PrependFloat32Slot(*args)

PrependFloat64(x)

Prepend a float64 to the Builder buffer.

Note: aligns and checks for space.

PrependFloat64Slot(*args)

PrependInt16(x)

Prepend an int16 to the Builder buffer.

Note: aligns and checks for space.

PrependInt16Slot(*args)

PrependInt32(x)

Prepend an int32 to the Builder buffer.

Note: aligns and checks for space.

PrependInt32Slot(*args)

PrependInt64(x)

Prepend an int64 to the Builder buffer.

Note: aligns and checks for space.

PrependInt64Slot(*args)

PrependInt8(x)

Prepend an int8 to the Builder buffer.

Note: aligns and checks for space.

PrependInt8Slot(*args)

PrependSOffsetTRelative(off)

PrependSOffsetTRelative prepends an SOffsetT, relative to where it will be written.

PrependSlot(flags, o, x, d)

PrependStructSlot(v, x, d)

PrependStructSlot prepends a struct onto the object at vtable slot o. Structs are stored inline, so nothing additional is being added. In generated code, d is always 0.

PrependUOffsetTRelative(off)

Prepends an unsigned offset into vector data, relative to where it will be written.

PrependUOffsetTRelativeSlot(o, x, d)

PrependUOffsetTRelativeSlot prepends an UOffsetT onto the object at vtable slot o. If value x equals default d, then the slot will be set to zero and no other data will be written.

PrependUint16(x)

Prepend an uint16 to the Builder buffer.

Note: aligns and checks for space.

PrependUint16Slot(*args)

PrependUint32(x)

Prepend an uint32 to the Builder buffer.

Note: aligns and checks for space.

PrependUint32Slot(*args)

PrependUint64(x)

Prepend an uint64 to the Builder buffer.

Note: aligns and checks for space.

PrependUint64Slot(*args)

PrependUint8(x)

Prepend an uint8 to the Builder buffer.

Note: aligns and checks for space.

PrependUint8Slot(*args)

PrependVOffsetT(x)

Slot(slotnum)

Slot sets the vtable key voffset to the current location in the buffer.

StartObject(numfields)

StartObject initializes bookkeeping for writing a new object.

StartVector(elemSize, numElems, alignment)

StartVector initializes bookkeeping for writing a new vector.

A vector has the following format:

• <UOffsetT: number of elements in this vector>

• <T: data>+, where T is the type of elements of this vector.

WriteVtable()

WriteVtable serializes the vtable for the current object, if needed.

Before writing out the vtable, this checks pre-existing vtables for equality to this one. If an equal vtable is found, point the object to the existing vtable and return.

Because vtable values are sensitive to alignment of object data, not all logically-equal vtables will be deduplicated.

A vtable has the following format:

<VOffsetT: size of the vtable in bytes, including this value> <VOffsetT: size of the object in bytes, including the vtable offset> <VOffsetT: offset for a field> * N, where N is the number of fields

in the schema for this type. Includes deprecated fields.

Thus, a vtable is made of 2 + N elements, each VOffsetT bytes wide.

An object has the following format:

<SOffsetT: offset to this object’s vtable (may be negative)> <byte: data>+

__Finish(rootTable, sizePrefix, file_identifier=None)

Finish finalizes a buffer, pointing to the given rootTable.

__slots__ = ('Bytes', 'current_vtable', 'head', 'minalign', 'objectEnd', 'vtables', 'nested',...

Maximum buffer size constant, in bytes.

Builder will never allow it’s buffer grow over this size. Currently equals 2Gb.

assertNested()

Check that we are in the process of building an object.

assertNotNested()

Check that no other objects are being built while making this object. If not, raise an exception.

assertStructIsInline(obj)

Structs are always stored inline, so need to be created right where they are used. You’ll get this error if you created it elsewhere.

current_vtable = None

finished = False

forceDefaults = False

growByteBuffer()

Doubles the size of the byteslice, and copies the old data towards the end of the new buffer (since we build the buffer backwards).

head

minalign = 1

nested = False

objectEnd = None

vtables

class Table(buf, pos)

Bases: object

Table wraps a byte slice and provides read access to its data.

The variable Pos indicates the root of the FlatBuffers object therein.

Bytes

Get(flags, off)

Get retrieves a value of the type specified by flags at the given offset.

GetSlot(slot, d, validator_flags)

GetVOffsetTSlot(slot, d)

GetVOffsetTSlot retrieves the VOffsetT that the given vtable location points to. If the vtable value is zero, the default value d will be returned.

GetVectorAsNumpy(flags, off)

GetVectorAsNumpy returns the vector that starts at Vector(off) as a numpy array with the type specified by flags. The array is a view into Bytes, so modifying the returned array will modify Bytes in place.

Indirect(off)

Indirect retrieves the relative offset stored at offset.

Offset(vtableOffset)

Offset provides access into the Table’s vtable.

Deprecated fields are ignored by checking the vtable’s length.

Pos

String(off)

String gets a string from data stored inside the flatbuffer.

Union(t2, off)

Union initializes any Table-derived type to point to the union at the given offset.

Vector(off)

Vector retrieves the start of data of the vector whose offset is stored at “off” in this object.

VectorLen(off)

VectorLen retrieves the length of the vector whose offset is stored at “off” in this object.

__slots__ = ('Bytes', 'Pos')

__git_version__ = 'v25.9.23'

version() → tuple[int, int, int, int | None, str | None]

Return the exact git version of the vendored FlatBuffers runtime.

Handles:

1. “v25.9.23” -> (25, 9, 23, None, None) # Release (Named Tag, CalVer Year.Month.Day)

2. “v25.9.23-71” -> (25, 9, 23, 71, None) # 71 commits ahead of the Release v25.9.23

3. “v25.9.23-71-g19b2300f” -> (25, 9, 23, 71, “19b2300f”) # dito, with Git commit hash