mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-01 19:58:15 +00:00
c526cb640b
This commit significantly improves the developer experience for the Python Object-Based API by overhauling the generated `__init__` method for `T`-suffixed classes.
Previously, `T` objects had to be instantiated with an empty constructor, and their fields had to be populated manually one by one. This was verbose and not idiomatic Python.
This change modifies the Python code generator (`GenInitialize`) to produce `__init__` methods that are:
1. **Keyword-Argument-Friendly**: The constructor now accepts all table/struct fields as keyword arguments, allowing for concise, single-line object creation.
2. **Fully Typed**: The signature of the `__init__` method is now annotated with Python type hints. This provides immediate benefits for static analysis tools (like Mypy) and IDEs, enabling better autocompletion and type checking.
3. **Correctly Optional**: The generator now correctly wraps types in `Optional[...]` if their default value is `None`. This applies to strings, vectors, and other nullable fields, ensuring strict type safety.
The new approach remains **fully backward-compatible**, as all arguments have default values. Existing code that uses the empty constructor will continue to work without modification.
#### Example of a Generated `__init__`
**Before:**
```python
class KeyValueT(object):
def __init__(self):
self.key = None # type: str
self.value = None # type: str
```
**After:**
```python
class KeyValueT(object):
def __init__(self, key: Optional[str] = None, value: Optional[str] = None):
self.key = key
self.value = value
```
#### Example of User Code
**Before:**
```python
# Old, verbose way
kv = KeyValueT()
kv.key = "instrument"
kv.value = "EUR/USD"
```
**After:**
```python
# New, Pythonic way
kv = KeyValueT(key="instrument", value="EUR/USD")
```
694 lines
24 KiB
Python
694 lines
24 KiB
Python
# automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
# namespace: optional_scalars
|
|
|
|
import flatbuffers
|
|
from flatbuffers.compat import import_numpy
|
|
np = import_numpy()
|
|
|
|
class ScalarStuff(object):
|
|
__slots__ = ['_tab']
|
|
|
|
@classmethod
|
|
def GetRootAs(cls, buf, offset=0):
|
|
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
|
|
x = ScalarStuff()
|
|
x.Init(buf, n + offset)
|
|
return x
|
|
|
|
@classmethod
|
|
def GetRootAsScalarStuff(cls, buf, offset=0):
|
|
"""This method is deprecated. Please switch to GetRootAs."""
|
|
return cls.GetRootAs(buf, offset)
|
|
@classmethod
|
|
def ScalarStuffBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
|
|
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4E\x55\x4C\x4C", size_prefixed=size_prefixed)
|
|
|
|
# ScalarStuff
|
|
def Init(self, buf, pos):
|
|
self._tab = flatbuffers.table.Table(buf, pos)
|
|
|
|
# ScalarStuff
|
|
def JustI8(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
|
|
|
|
# ScalarStuff
|
|
def MaybeI8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultI8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustU8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeU8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultU8(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustI16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeI16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultI16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustU16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeU16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultU16(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustI32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeI32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultI32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustU32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeU32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultU32(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 42
|
|
|
|
# ScalarStuff
|
|
def JustI64(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
|
|
|
|
# ScalarStuff
|
|
def MaybeI64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultI64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
|
return 42
|
|
|
|
# ScalarStuff
|
|
def JustU64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeU64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultU64(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 42
|
|
|
|
# ScalarStuff
|
|
def JustF32(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
|
return 0.0
|
|
|
|
# ScalarStuff
|
|
def MaybeF32(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 None
|
|
|
|
# ScalarStuff
|
|
def DefaultF32(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 42.0
|
|
|
|
# ScalarStuff
|
|
def JustF64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
|
return 0.0
|
|
|
|
# ScalarStuff
|
|
def MaybeF64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultF64(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
|
return 42.0
|
|
|
|
# ScalarStuff
|
|
def JustBool(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
|
if o != 0:
|
|
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
|
return False
|
|
|
|
# ScalarStuff
|
|
def MaybeBool(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
|
|
if o != 0:
|
|
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultBool(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
|
if o != 0:
|
|
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
|
return True
|
|
|
|
# ScalarStuff
|
|
def JustEnum(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return 0
|
|
|
|
# ScalarStuff
|
|
def MaybeEnum(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return None
|
|
|
|
# ScalarStuff
|
|
def DefaultEnum(self):
|
|
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
|
|
if o != 0:
|
|
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
|
return 1
|
|
|
|
def ScalarStuffStart(builder):
|
|
builder.StartObject(36)
|
|
|
|
def Start(builder):
|
|
ScalarStuffStart(builder)
|
|
|
|
def ScalarStuffAddJustI8(builder, justI8):
|
|
builder.PrependInt8Slot(0, justI8, 0)
|
|
|
|
def AddJustI8(builder, justI8):
|
|
ScalarStuffAddJustI8(builder, justI8)
|
|
|
|
def ScalarStuffAddMaybeI8(builder, maybeI8):
|
|
builder.PrependInt8Slot(1, maybeI8, None)
|
|
|
|
def AddMaybeI8(builder, maybeI8):
|
|
ScalarStuffAddMaybeI8(builder, maybeI8)
|
|
|
|
def ScalarStuffAddDefaultI8(builder, defaultI8):
|
|
builder.PrependInt8Slot(2, defaultI8, 42)
|
|
|
|
def AddDefaultI8(builder, defaultI8):
|
|
ScalarStuffAddDefaultI8(builder, defaultI8)
|
|
|
|
def ScalarStuffAddJustU8(builder, justU8):
|
|
builder.PrependUint8Slot(3, justU8, 0)
|
|
|
|
def AddJustU8(builder, justU8):
|
|
ScalarStuffAddJustU8(builder, justU8)
|
|
|
|
def ScalarStuffAddMaybeU8(builder, maybeU8):
|
|
builder.PrependUint8Slot(4, maybeU8, None)
|
|
|
|
def AddMaybeU8(builder, maybeU8):
|
|
ScalarStuffAddMaybeU8(builder, maybeU8)
|
|
|
|
def ScalarStuffAddDefaultU8(builder, defaultU8):
|
|
builder.PrependUint8Slot(5, defaultU8, 42)
|
|
|
|
def AddDefaultU8(builder, defaultU8):
|
|
ScalarStuffAddDefaultU8(builder, defaultU8)
|
|
|
|
def ScalarStuffAddJustI16(builder, justI16):
|
|
builder.PrependInt16Slot(6, justI16, 0)
|
|
|
|
def AddJustI16(builder, justI16):
|
|
ScalarStuffAddJustI16(builder, justI16)
|
|
|
|
def ScalarStuffAddMaybeI16(builder, maybeI16):
|
|
builder.PrependInt16Slot(7, maybeI16, None)
|
|
|
|
def AddMaybeI16(builder, maybeI16):
|
|
ScalarStuffAddMaybeI16(builder, maybeI16)
|
|
|
|
def ScalarStuffAddDefaultI16(builder, defaultI16):
|
|
builder.PrependInt16Slot(8, defaultI16, 42)
|
|
|
|
def AddDefaultI16(builder, defaultI16):
|
|
ScalarStuffAddDefaultI16(builder, defaultI16)
|
|
|
|
def ScalarStuffAddJustU16(builder, justU16):
|
|
builder.PrependUint16Slot(9, justU16, 0)
|
|
|
|
def AddJustU16(builder, justU16):
|
|
ScalarStuffAddJustU16(builder, justU16)
|
|
|
|
def ScalarStuffAddMaybeU16(builder, maybeU16):
|
|
builder.PrependUint16Slot(10, maybeU16, None)
|
|
|
|
def AddMaybeU16(builder, maybeU16):
|
|
ScalarStuffAddMaybeU16(builder, maybeU16)
|
|
|
|
def ScalarStuffAddDefaultU16(builder, defaultU16):
|
|
builder.PrependUint16Slot(11, defaultU16, 42)
|
|
|
|
def AddDefaultU16(builder, defaultU16):
|
|
ScalarStuffAddDefaultU16(builder, defaultU16)
|
|
|
|
def ScalarStuffAddJustI32(builder, justI32):
|
|
builder.PrependInt32Slot(12, justI32, 0)
|
|
|
|
def AddJustI32(builder, justI32):
|
|
ScalarStuffAddJustI32(builder, justI32)
|
|
|
|
def ScalarStuffAddMaybeI32(builder, maybeI32):
|
|
builder.PrependInt32Slot(13, maybeI32, None)
|
|
|
|
def AddMaybeI32(builder, maybeI32):
|
|
ScalarStuffAddMaybeI32(builder, maybeI32)
|
|
|
|
def ScalarStuffAddDefaultI32(builder, defaultI32):
|
|
builder.PrependInt32Slot(14, defaultI32, 42)
|
|
|
|
def AddDefaultI32(builder, defaultI32):
|
|
ScalarStuffAddDefaultI32(builder, defaultI32)
|
|
|
|
def ScalarStuffAddJustU32(builder, justU32):
|
|
builder.PrependUint32Slot(15, justU32, 0)
|
|
|
|
def AddJustU32(builder, justU32):
|
|
ScalarStuffAddJustU32(builder, justU32)
|
|
|
|
def ScalarStuffAddMaybeU32(builder, maybeU32):
|
|
builder.PrependUint32Slot(16, maybeU32, None)
|
|
|
|
def AddMaybeU32(builder, maybeU32):
|
|
ScalarStuffAddMaybeU32(builder, maybeU32)
|
|
|
|
def ScalarStuffAddDefaultU32(builder, defaultU32):
|
|
builder.PrependUint32Slot(17, defaultU32, 42)
|
|
|
|
def AddDefaultU32(builder, defaultU32):
|
|
ScalarStuffAddDefaultU32(builder, defaultU32)
|
|
|
|
def ScalarStuffAddJustI64(builder, justI64):
|
|
builder.PrependInt64Slot(18, justI64, 0)
|
|
|
|
def AddJustI64(builder, justI64):
|
|
ScalarStuffAddJustI64(builder, justI64)
|
|
|
|
def ScalarStuffAddMaybeI64(builder, maybeI64):
|
|
builder.PrependInt64Slot(19, maybeI64, None)
|
|
|
|
def AddMaybeI64(builder, maybeI64):
|
|
ScalarStuffAddMaybeI64(builder, maybeI64)
|
|
|
|
def ScalarStuffAddDefaultI64(builder, defaultI64):
|
|
builder.PrependInt64Slot(20, defaultI64, 42)
|
|
|
|
def AddDefaultI64(builder, defaultI64):
|
|
ScalarStuffAddDefaultI64(builder, defaultI64)
|
|
|
|
def ScalarStuffAddJustU64(builder, justU64):
|
|
builder.PrependUint64Slot(21, justU64, 0)
|
|
|
|
def AddJustU64(builder, justU64):
|
|
ScalarStuffAddJustU64(builder, justU64)
|
|
|
|
def ScalarStuffAddMaybeU64(builder, maybeU64):
|
|
builder.PrependUint64Slot(22, maybeU64, None)
|
|
|
|
def AddMaybeU64(builder, maybeU64):
|
|
ScalarStuffAddMaybeU64(builder, maybeU64)
|
|
|
|
def ScalarStuffAddDefaultU64(builder, defaultU64):
|
|
builder.PrependUint64Slot(23, defaultU64, 42)
|
|
|
|
def AddDefaultU64(builder, defaultU64):
|
|
ScalarStuffAddDefaultU64(builder, defaultU64)
|
|
|
|
def ScalarStuffAddJustF32(builder, justF32):
|
|
builder.PrependFloat32Slot(24, justF32, 0.0)
|
|
|
|
def AddJustF32(builder, justF32):
|
|
ScalarStuffAddJustF32(builder, justF32)
|
|
|
|
def ScalarStuffAddMaybeF32(builder, maybeF32):
|
|
builder.PrependFloat32Slot(25, maybeF32, None)
|
|
|
|
def AddMaybeF32(builder, maybeF32):
|
|
ScalarStuffAddMaybeF32(builder, maybeF32)
|
|
|
|
def ScalarStuffAddDefaultF32(builder, defaultF32):
|
|
builder.PrependFloat32Slot(26, defaultF32, 42.0)
|
|
|
|
def AddDefaultF32(builder, defaultF32):
|
|
ScalarStuffAddDefaultF32(builder, defaultF32)
|
|
|
|
def ScalarStuffAddJustF64(builder, justF64):
|
|
builder.PrependFloat64Slot(27, justF64, 0.0)
|
|
|
|
def AddJustF64(builder, justF64):
|
|
ScalarStuffAddJustF64(builder, justF64)
|
|
|
|
def ScalarStuffAddMaybeF64(builder, maybeF64):
|
|
builder.PrependFloat64Slot(28, maybeF64, None)
|
|
|
|
def AddMaybeF64(builder, maybeF64):
|
|
ScalarStuffAddMaybeF64(builder, maybeF64)
|
|
|
|
def ScalarStuffAddDefaultF64(builder, defaultF64):
|
|
builder.PrependFloat64Slot(29, defaultF64, 42.0)
|
|
|
|
def AddDefaultF64(builder, defaultF64):
|
|
ScalarStuffAddDefaultF64(builder, defaultF64)
|
|
|
|
def ScalarStuffAddJustBool(builder, justBool):
|
|
builder.PrependBoolSlot(30, justBool, 0)
|
|
|
|
def AddJustBool(builder, justBool):
|
|
ScalarStuffAddJustBool(builder, justBool)
|
|
|
|
def ScalarStuffAddMaybeBool(builder, maybeBool):
|
|
builder.PrependBoolSlot(31, maybeBool, None)
|
|
|
|
def AddMaybeBool(builder, maybeBool):
|
|
ScalarStuffAddMaybeBool(builder, maybeBool)
|
|
|
|
def ScalarStuffAddDefaultBool(builder, defaultBool):
|
|
builder.PrependBoolSlot(32, defaultBool, 1)
|
|
|
|
def AddDefaultBool(builder, defaultBool):
|
|
ScalarStuffAddDefaultBool(builder, defaultBool)
|
|
|
|
def ScalarStuffAddJustEnum(builder, justEnum):
|
|
builder.PrependInt8Slot(33, justEnum, 0)
|
|
|
|
def AddJustEnum(builder, justEnum):
|
|
ScalarStuffAddJustEnum(builder, justEnum)
|
|
|
|
def ScalarStuffAddMaybeEnum(builder, maybeEnum):
|
|
builder.PrependInt8Slot(34, maybeEnum, None)
|
|
|
|
def AddMaybeEnum(builder, maybeEnum):
|
|
ScalarStuffAddMaybeEnum(builder, maybeEnum)
|
|
|
|
def ScalarStuffAddDefaultEnum(builder, defaultEnum):
|
|
builder.PrependInt8Slot(35, defaultEnum, 1)
|
|
|
|
def AddDefaultEnum(builder, defaultEnum):
|
|
ScalarStuffAddDefaultEnum(builder, defaultEnum)
|
|
|
|
def ScalarStuffEnd(builder):
|
|
return builder.EndObject()
|
|
|
|
def End(builder):
|
|
return ScalarStuffEnd(builder)
|
|
|
|
try:
|
|
from typing import Optional
|
|
except:
|
|
pass
|
|
|
|
class ScalarStuffT(object):
|
|
|
|
# ScalarStuffT
|
|
def __init__(
|
|
self,
|
|
justI8 = 0,
|
|
maybeI8 = None,
|
|
defaultI8 = 42,
|
|
justU8 = 0,
|
|
maybeU8 = None,
|
|
defaultU8 = 42,
|
|
justI16 = 0,
|
|
maybeI16 = None,
|
|
defaultI16 = 42,
|
|
justU16 = 0,
|
|
maybeU16 = None,
|
|
defaultU16 = 42,
|
|
justI32 = 0,
|
|
maybeI32 = None,
|
|
defaultI32 = 42,
|
|
justU32 = 0,
|
|
maybeU32 = None,
|
|
defaultU32 = 42,
|
|
justI64 = 0,
|
|
maybeI64 = None,
|
|
defaultI64 = 42,
|
|
justU64 = 0,
|
|
maybeU64 = None,
|
|
defaultU64 = 42,
|
|
justF32 = 0.0,
|
|
maybeF32 = None,
|
|
defaultF32 = 42.0,
|
|
justF64 = 0.0,
|
|
maybeF64 = None,
|
|
defaultF64 = 42.0,
|
|
justBool = False,
|
|
maybeBool = None,
|
|
defaultBool = True,
|
|
justEnum = 0,
|
|
maybeEnum = None,
|
|
defaultEnum = 1,
|
|
):
|
|
self.justI8 = justI8 # type: int
|
|
self.maybeI8 = maybeI8 # type: Optional[int]
|
|
self.defaultI8 = defaultI8 # type: int
|
|
self.justU8 = justU8 # type: int
|
|
self.maybeU8 = maybeU8 # type: Optional[int]
|
|
self.defaultU8 = defaultU8 # type: int
|
|
self.justI16 = justI16 # type: int
|
|
self.maybeI16 = maybeI16 # type: Optional[int]
|
|
self.defaultI16 = defaultI16 # type: int
|
|
self.justU16 = justU16 # type: int
|
|
self.maybeU16 = maybeU16 # type: Optional[int]
|
|
self.defaultU16 = defaultU16 # type: int
|
|
self.justI32 = justI32 # type: int
|
|
self.maybeI32 = maybeI32 # type: Optional[int]
|
|
self.defaultI32 = defaultI32 # type: int
|
|
self.justU32 = justU32 # type: int
|
|
self.maybeU32 = maybeU32 # type: Optional[int]
|
|
self.defaultU32 = defaultU32 # type: int
|
|
self.justI64 = justI64 # type: int
|
|
self.maybeI64 = maybeI64 # type: Optional[int]
|
|
self.defaultI64 = defaultI64 # type: int
|
|
self.justU64 = justU64 # type: int
|
|
self.maybeU64 = maybeU64 # type: Optional[int]
|
|
self.defaultU64 = defaultU64 # type: int
|
|
self.justF32 = justF32 # type: float
|
|
self.maybeF32 = maybeF32 # type: Optional[float]
|
|
self.defaultF32 = defaultF32 # type: float
|
|
self.justF64 = justF64 # type: float
|
|
self.maybeF64 = maybeF64 # type: Optional[float]
|
|
self.defaultF64 = defaultF64 # type: float
|
|
self.justBool = justBool # type: bool
|
|
self.maybeBool = maybeBool # type: Optional[bool]
|
|
self.defaultBool = defaultBool # type: bool
|
|
self.justEnum = justEnum # type: int
|
|
self.maybeEnum = maybeEnum # type: Optional[int]
|
|
self.defaultEnum = defaultEnum # type: int
|
|
|
|
@classmethod
|
|
def InitFromBuf(cls, buf, pos):
|
|
scalarStuff = ScalarStuff()
|
|
scalarStuff.Init(buf, pos)
|
|
return cls.InitFromObj(scalarStuff)
|
|
|
|
@classmethod
|
|
def InitFromPackedBuf(cls, buf, pos=0):
|
|
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
|
|
return cls.InitFromBuf(buf, pos+n)
|
|
|
|
@classmethod
|
|
def InitFromObj(cls, scalarStuff):
|
|
x = ScalarStuffT()
|
|
x._UnPack(scalarStuff)
|
|
return x
|
|
|
|
# ScalarStuffT
|
|
def _UnPack(self, scalarStuff):
|
|
if scalarStuff is None:
|
|
return
|
|
self.justI8 = scalarStuff.JustI8()
|
|
self.maybeI8 = scalarStuff.MaybeI8()
|
|
self.defaultI8 = scalarStuff.DefaultI8()
|
|
self.justU8 = scalarStuff.JustU8()
|
|
self.maybeU8 = scalarStuff.MaybeU8()
|
|
self.defaultU8 = scalarStuff.DefaultU8()
|
|
self.justI16 = scalarStuff.JustI16()
|
|
self.maybeI16 = scalarStuff.MaybeI16()
|
|
self.defaultI16 = scalarStuff.DefaultI16()
|
|
self.justU16 = scalarStuff.JustU16()
|
|
self.maybeU16 = scalarStuff.MaybeU16()
|
|
self.defaultU16 = scalarStuff.DefaultU16()
|
|
self.justI32 = scalarStuff.JustI32()
|
|
self.maybeI32 = scalarStuff.MaybeI32()
|
|
self.defaultI32 = scalarStuff.DefaultI32()
|
|
self.justU32 = scalarStuff.JustU32()
|
|
self.maybeU32 = scalarStuff.MaybeU32()
|
|
self.defaultU32 = scalarStuff.DefaultU32()
|
|
self.justI64 = scalarStuff.JustI64()
|
|
self.maybeI64 = scalarStuff.MaybeI64()
|
|
self.defaultI64 = scalarStuff.DefaultI64()
|
|
self.justU64 = scalarStuff.JustU64()
|
|
self.maybeU64 = scalarStuff.MaybeU64()
|
|
self.defaultU64 = scalarStuff.DefaultU64()
|
|
self.justF32 = scalarStuff.JustF32()
|
|
self.maybeF32 = scalarStuff.MaybeF32()
|
|
self.defaultF32 = scalarStuff.DefaultF32()
|
|
self.justF64 = scalarStuff.JustF64()
|
|
self.maybeF64 = scalarStuff.MaybeF64()
|
|
self.defaultF64 = scalarStuff.DefaultF64()
|
|
self.justBool = scalarStuff.JustBool()
|
|
self.maybeBool = scalarStuff.MaybeBool()
|
|
self.defaultBool = scalarStuff.DefaultBool()
|
|
self.justEnum = scalarStuff.JustEnum()
|
|
self.maybeEnum = scalarStuff.MaybeEnum()
|
|
self.defaultEnum = scalarStuff.DefaultEnum()
|
|
|
|
# ScalarStuffT
|
|
def Pack(self, builder):
|
|
ScalarStuffStart(builder)
|
|
ScalarStuffAddJustI8(builder, self.justI8)
|
|
ScalarStuffAddMaybeI8(builder, self.maybeI8)
|
|
ScalarStuffAddDefaultI8(builder, self.defaultI8)
|
|
ScalarStuffAddJustU8(builder, self.justU8)
|
|
ScalarStuffAddMaybeU8(builder, self.maybeU8)
|
|
ScalarStuffAddDefaultU8(builder, self.defaultU8)
|
|
ScalarStuffAddJustI16(builder, self.justI16)
|
|
ScalarStuffAddMaybeI16(builder, self.maybeI16)
|
|
ScalarStuffAddDefaultI16(builder, self.defaultI16)
|
|
ScalarStuffAddJustU16(builder, self.justU16)
|
|
ScalarStuffAddMaybeU16(builder, self.maybeU16)
|
|
ScalarStuffAddDefaultU16(builder, self.defaultU16)
|
|
ScalarStuffAddJustI32(builder, self.justI32)
|
|
ScalarStuffAddMaybeI32(builder, self.maybeI32)
|
|
ScalarStuffAddDefaultI32(builder, self.defaultI32)
|
|
ScalarStuffAddJustU32(builder, self.justU32)
|
|
ScalarStuffAddMaybeU32(builder, self.maybeU32)
|
|
ScalarStuffAddDefaultU32(builder, self.defaultU32)
|
|
ScalarStuffAddJustI64(builder, self.justI64)
|
|
ScalarStuffAddMaybeI64(builder, self.maybeI64)
|
|
ScalarStuffAddDefaultI64(builder, self.defaultI64)
|
|
ScalarStuffAddJustU64(builder, self.justU64)
|
|
ScalarStuffAddMaybeU64(builder, self.maybeU64)
|
|
ScalarStuffAddDefaultU64(builder, self.defaultU64)
|
|
ScalarStuffAddJustF32(builder, self.justF32)
|
|
ScalarStuffAddMaybeF32(builder, self.maybeF32)
|
|
ScalarStuffAddDefaultF32(builder, self.defaultF32)
|
|
ScalarStuffAddJustF64(builder, self.justF64)
|
|
ScalarStuffAddMaybeF64(builder, self.maybeF64)
|
|
ScalarStuffAddDefaultF64(builder, self.defaultF64)
|
|
ScalarStuffAddJustBool(builder, self.justBool)
|
|
ScalarStuffAddMaybeBool(builder, self.maybeBool)
|
|
ScalarStuffAddDefaultBool(builder, self.defaultBool)
|
|
ScalarStuffAddJustEnum(builder, self.justEnum)
|
|
ScalarStuffAddMaybeEnum(builder, self.maybeEnum)
|
|
ScalarStuffAddDefaultEnum(builder, self.defaultEnum)
|
|
scalarStuff = ScalarStuffEnd(builder)
|
|
return scalarStuff
|