parent
26f42e2e70
commit
ef5527be03
@ -1,10 +1,10 @@
|
||||
-/build/
|
||||
-/.waf*
|
||||
-/.lock-waf*
|
||||
-/flatpy/.env/
|
||||
-/website/.venv/
|
||||
-/website/_serve/
|
||||
-/website/_build/
|
||||
-/3rdparty/qnanopainter/
|
||||
-/3rdparty/subprocess/
|
||||
-/3rdparty/dep_sort/
|
||||
-/3rdparty/flatpy/
|
||||
|
||||
@ -0,0 +1 @@
|
||||
Subproject commit bf1a4e391ffcd484f627ba81ae54ffe0c073acb9
|
||||
@ -1,249 +0,0 @@
|
||||
# Generated file, do not edit!
|
||||
|
||||
import enum
|
||||
import flatbuffers
|
||||
from typing import Any, Dict, List, Optional, Union
|
||||
|
||||
{% for mod, syms in schema.imports %}
|
||||
from {{ mod }} import {{ ', '.join(syms) }}
|
||||
{% endfor %}
|
||||
|
||||
NT = flatbuffers.number_types
|
||||
|
||||
{% for enum in schema.enums %}
|
||||
{% if enum.emit %}
|
||||
class {{ enum.name }}(enum.IntEnum):
|
||||
{% for val in enum['values'] -%}
|
||||
{{ val.name }} = {{ val.value }}
|
||||
{% endfor -%}
|
||||
{% endif %}
|
||||
{% endfor %}
|
||||
|
||||
{% for obj in schema.objects %}
|
||||
{% if obj.emit %}
|
||||
class {{ obj.name }}:
|
||||
def __init__(self, src: Union[flatbuffers.Table, bytes, bytearray]) -> None:
|
||||
self._buf = None # type: Optional[bytes]
|
||||
if isinstance(src, flatbuffers.Table):
|
||||
self._tab = src
|
||||
elif isinstance(src, (bytearray, bytes)):
|
||||
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, src, 0)
|
||||
self._tab = flatbuffers.table.Table(src, n)
|
||||
self._buf = src
|
||||
else:
|
||||
raise TypeError(type(src).__name__)
|
||||
|
||||
def Buffer(self) -> bytes:
|
||||
assert self._buf is not None
|
||||
return self._buf
|
||||
|
||||
{% for field in obj.fields %}
|
||||
@property
|
||||
def {{ field.name }}(self) -> {{ field.py_type }}:
|
||||
{% if field.documentation | length -%}
|
||||
"""{% for l in field.documentation %}{{ l|trim }}
|
||||
{% endfor %}"""
|
||||
{% endif -%}
|
||||
{% if field.type.base_type == 'String' -%}
|
||||
o = NT.UOffsetTFlags.py_type(self._tab.Offset({{ field.offset }}))
|
||||
if o != 0:
|
||||
return self._tab.String(o + self._tab.Pos).decode('utf-8')
|
||||
return None
|
||||
|
||||
{% elif field.type.base_type == 'Vector' -%}
|
||||
o = NT.UOffsetTFlags.py_type(self._tab.Offset({{ field.offset }}))
|
||||
if o != 0:
|
||||
base = self._tab.Vector(o)
|
||||
{% if field.type.element == 'String' -%}
|
||||
v = [] # type: List[str]
|
||||
for i in range(self._tab.VectorLen(o)):
|
||||
v.append(self._tab.String(base + i * NT.UOffsetTFlags.bytewidth).decode('utf-8'))
|
||||
return v
|
||||
{% elif field.type.element == 'Obj' -%}
|
||||
v = [] # type: List[flatbuffers.table.Table]
|
||||
for i in range(self._tab.VectorLen(o)):
|
||||
o = base + i * NT.UOffsetTFlags.bytewidth
|
||||
o = self._tab.Indirect(o)
|
||||
obj = {{ schema.objects[field.type.index].name }}(flatbuffers.table.Table(self._tab.Bytes, o))
|
||||
v.append(obj)
|
||||
return v
|
||||
{% elif field.type.element == 'UByte' -%}
|
||||
return self._tab.Bytes[base:base+self._tab.VectorLen(o)]
|
||||
{% else -%}
|
||||
v = [] # type: List[int]
|
||||
for i in range(self._tab.VectorLen(o)):
|
||||
v.append(self._tab.Get(NT.{{ field.type.element | title }}Flags, base + i * NT.{{ field.type.element | title }}Flags.bytewidth))
|
||||
return v
|
||||
{% endif %}
|
||||
return None
|
||||
|
||||
{% elif field.type.base_type == 'Obj' -%}
|
||||
o = NT.UOffsetTFlags.py_type(self._tab.Offset({{ field.offset }}))
|
||||
if o != 0:
|
||||
tab = flatbuffers.table.Table(bytearray(), 0)
|
||||
self._tab.Union(tab, o)
|
||||
return {{ schema.objects[field.type.index].name }}(tab)
|
||||
return None
|
||||
|
||||
{% elif field.type.base_type == 'Union' -%}
|
||||
o = NT.UOffsetTFlags.py_type(self._tab.Offset({{ field.offset }}))
|
||||
if o != 0:
|
||||
obj = flatbuffers.table.Table(bytearray(), 0)
|
||||
self._tab.Union(obj, o)
|
||||
return obj
|
||||
return None
|
||||
|
||||
{% elif field.type.base_type == 'UType' -%}
|
||||
o = NT.UOffsetTFlags.py_type(self._tab.Offset({{ field.offset }}))
|
||||
if o != 0:
|
||||
return self._tab.Get(NT.Uint8Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
{% else -%}
|
||||
o = NT.UOffsetTFlags.py_type(self._tab.Offset({{ field.offset }}))
|
||||
if o != 0:
|
||||
return self._tab.Get(NT.{{ field.type.base_type | title }}Flags, o + self._tab.Pos)
|
||||
return {{ field.default }}
|
||||
|
||||
{% endif %}
|
||||
|
||||
{% endfor %}
|
||||
|
||||
def Create{{obj.name}}(
|
||||
builder: flatbuffers.Builder,{% if obj.fields %} *,{% endif %}
|
||||
{%- for field in obj.fields %}
|
||||
{{ field.name }}: Optional[{{ field.py_type }}]=None,
|
||||
{%- endfor %}
|
||||
) -> int:
|
||||
{%- for field in obj.fields %}
|
||||
{% if field.type.base_type == 'String' -%}
|
||||
if {{ field.name }} is not None:
|
||||
{{ field.name }}_offset = builder.CreateString({{ field.name }})
|
||||
else:
|
||||
{{ field.name }}_offset = None
|
||||
{% elif field.type.base_type == 'Vector' -%}
|
||||
if {{ field.name }} is not None:
|
||||
{% if field.type.element == 'String' -%}
|
||||
elems = [] # type: List[int]
|
||||
for el in {{ field.name }}:
|
||||
elems.append(builder.CreateString(el))
|
||||
builder.StartVector(NT.UOffsetTFlags.bytewidth, len(elems), 0)
|
||||
for el in reversed(elems):
|
||||
builder.PrependUOffsetTRelative(el)
|
||||
{{ field.name }}_offset = builder.EndVector()
|
||||
{% elif field.type.element == 'Obj' -%}
|
||||
builder.StartVector(NT.UOffsetTFlags.bytewidth, len({{ field.name }}), 0)
|
||||
for el in reversed({{ field.name }}):
|
||||
builder.PrependUOffsetTRelative(el)
|
||||
{{ field.name }}_offset = builder.EndVector()
|
||||
{% else -%}
|
||||
builder.StartVector(NT.{{ field.type.element | title }}Flags.bytewidth, len({{ field.name }}), 0)
|
||||
for el in reversed({{ field.name }}):
|
||||
builder.Prepend(NT.{{ field.type.element | title }}Flags, el)
|
||||
{{ field.name }}_offset = builder.EndVector()
|
||||
{% endif %}
|
||||
else:
|
||||
{{ field.name }}_offset = None
|
||||
{%- endif %}
|
||||
{%- endfor %}
|
||||
|
||||
builder.StartObject({{ obj.fields | length }})
|
||||
{%- for field in obj.fields %}
|
||||
{% if field.type.base_type in ('String', 'Vector') -%}
|
||||
if {{ field.name }}_offset is not None:
|
||||
builder.PrependUOffsetTRelativeSlot({{ field.id }}, NT.UOffsetTFlags.py_type({{ field.name }}_offset), 0)
|
||||
|
||||
{% elif field.type.base_type in ('Obj', 'Union') -%}
|
||||
if {{ field.name }} is not None:
|
||||
builder.PrependUOffsetTRelativeSlot({{ field.id }}, NT.UOffsetTFlags.py_type({{ field.name }}), 0)
|
||||
|
||||
{% elif field.type.base_type == 'UType' -%}
|
||||
if {{ field.name }} is not None:
|
||||
builder.PrependSlot(NT.Uint8Flags, {{ field.id }}, NT.UOffsetTFlags.py_type({{ field.name }}), 0)
|
||||
|
||||
{% else -%}
|
||||
if {{ field.name }} is not None:
|
||||
builder.PrependSlot(NT.{{ field.type.base_type | title }}Flags, {{ field.id }}, {{ field.name }}, 0)
|
||||
|
||||
{% endif %}
|
||||
{%- endfor %}
|
||||
return builder.EndObject()
|
||||
|
||||
|
||||
def Create{{obj.name}}FromJSON(
|
||||
builder: flatbuffers.Builder, j: Dict[str, Any], strict: bool = True) -> int:
|
||||
{%- for field in obj.fields %}
|
||||
{{ field.name }} = j.pop('{{ field.name }}', None)
|
||||
{% if field.type.base_type == 'String' -%}
|
||||
if {{ field.name }} is not None:
|
||||
{{ field.name }}_offset = builder.CreateString({{ field.name }})
|
||||
else:
|
||||
{{ field.name }}_offset = None
|
||||
{% elif field.type.base_type == 'Obj' -%}
|
||||
if {{ field.name }} is not None:
|
||||
{{ field.name }}_offset = Create{{ schema.objects[field.type.index].name }}FromJSON(builder, {{ field.name }})
|
||||
else:
|
||||
{{ field.name }}_offset = None
|
||||
{% elif field.type.base_type == 'Vector' -%}
|
||||
if {{ field.name }} is not None:
|
||||
{% if field.type.element == 'String' -%}
|
||||
elems = [] # type: List[int]
|
||||
for el in {{ field.name }}:
|
||||
elems.append(builder.CreateString(el))
|
||||
builder.StartVector(NT.UOffsetTFlags.bytewidth, len(elems), 0)
|
||||
for el in reversed(elems):
|
||||
builder.PrependUOffsetTRelative(el)
|
||||
{{ field.name }}_offset = builder.EndVector()
|
||||
{% elif field.type.element == 'Obj' -%}
|
||||
elems = [] # type: List[int]
|
||||
for el in {{ field.name }}:
|
||||
elems.append(Create{{ schema.objects[field.type.index].name }}FromJSON(builder, el))
|
||||
builder.StartVector(NT.UOffsetTFlags.bytewidth, len({{ field.name }}), 0)
|
||||
for el in reversed(elems):
|
||||
builder.PrependUOffsetTRelative(el)
|
||||
{{ field.name }}_offset = builder.EndVector()
|
||||
{% elif field.type.index >= 0 %}
|
||||
builder.StartVector(NT.Int32Flags.bytewidth, len({{ field.name }}), 0)
|
||||
for el in reversed({{ field.name }}):
|
||||
builder.Prepend(NT.Int32Flags, {{ schema.enums[field.type.index].name }}[el])
|
||||
{{ field.name }}_offset = builder.EndVector()
|
||||
{% else -%}
|
||||
builder.StartVector(NT.{{ field.type.element | title }}Flags.bytewidth, len({{ field.name }}), 0)
|
||||
for el in reversed({{ field.name }}):
|
||||
builder.Prepend(NT.{{ field.type.element | title }}Flags, el)
|
||||
{{ field.name }}_offset = builder.EndVector()
|
||||
{% endif %}
|
||||
else:
|
||||
{{ field.name }}_offset = None
|
||||
{% elif field.type.index >= 0 %}
|
||||
if {{ field.name }} is not None:
|
||||
{{ field.name }} = {{ schema.enums[field.type.index].name }}[{{ field.name }}]
|
||||
{%- endif %}
|
||||
{%- endfor %}
|
||||
|
||||
if strict and j:
|
||||
raise ValueError("Unknown field(s) in JSON input: {}".format(", ".join(sorted(j.keys()))))
|
||||
|
||||
builder.StartObject({{ obj.fields | length }})
|
||||
{%- for field in obj.fields %}
|
||||
{% if field.type.base_type in ('String', 'Vector', 'Obj') -%}
|
||||
if {{ field.name }}_offset is not None:
|
||||
builder.PrependUOffsetTRelativeSlot({{ field.id }}, NT.UOffsetTFlags.py_type({{ field.name }}_offset), 0)
|
||||
|
||||
{% elif field.type.base_type == 'Union' -%}
|
||||
if {{ field.name }} is not None:
|
||||
builder.PrependUOffsetTRelativeSlot({{ field.id }}, NT.UOffsetTFlags.py_type({{ field.name }}), 0)
|
||||
|
||||
{% elif field.type.base_type == 'UType' -%}
|
||||
if {{ field.name }} is not None:
|
||||
builder.PrependSlot(NT.Uint8Flags, {{ field.id }}, NT.UOffsetTFlags.py_type({{ field.name }}), 0)
|
||||
|
||||
{% else -%}
|
||||
if {{ field.name }} is not None:
|
||||
builder.PrependSlot(NT.{{ field.type.base_type | title }}Flags, {{ field.id }}, {{ field.name }}, 0)
|
||||
|
||||
{% endif %}
|
||||
{%- endfor %}
|
||||
return builder.EndObject()
|
||||
{% endif %}
|
||||
{% endfor %}
|
||||
@ -1,183 +0,0 @@
|
||||
import argparse
|
||||
import json
|
||||
import os.path
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import stat
|
||||
import sys
|
||||
|
||||
import jinja2
|
||||
|
||||
MIN_FLATC_VERSION = (2, 0, 0)
|
||||
|
||||
py_types = {
|
||||
'Bool': 'bool',
|
||||
'UInt8': 'int',
|
||||
'UInt16': 'int',
|
||||
'UInt32': 'int',
|
||||
'UInt64': 'int',
|
||||
'Int8': 'int',
|
||||
'Int16': 'int',
|
||||
'Int32': 'int',
|
||||
'Int64': 'int',
|
||||
'Float32': 'float',
|
||||
'Float64': 'float',
|
||||
'String': 'str',
|
||||
'Vector': 'List',
|
||||
'Union': 'flatbuffers.Table',
|
||||
'Obj': 'flatbuffers.Table',
|
||||
'UType': 'int',
|
||||
}
|
||||
|
||||
defaults = {
|
||||
'Bool': False,
|
||||
'UInt8': 0,
|
||||
'UInt16': 0,
|
||||
'UInt32': 0,
|
||||
'UInt64': 0,
|
||||
'Int8': 0,
|
||||
'Int16': 0,
|
||||
'Int32': 0,
|
||||
'Int64': 0,
|
||||
'Float32': 0.0,
|
||||
'Float64': 0.0,
|
||||
'String': None,
|
||||
'Vector': None,
|
||||
'Union': None,
|
||||
'Obj': None,
|
||||
'UType': 0,
|
||||
}
|
||||
|
||||
type_aliases = {
|
||||
'Byte': 'Int8',
|
||||
'UByte': 'UInt8',
|
||||
'Short': 'Int16',
|
||||
'UShort': 'UInt16',
|
||||
'Int': 'Int32',
|
||||
'UInt': 'UInt32',
|
||||
'Long': 'Int64',
|
||||
'ULong': 'UInt64',
|
||||
'Float': 'Float32',
|
||||
'Double': 'Float64',
|
||||
}
|
||||
|
||||
def gen(args, base_name, schema_path):
|
||||
with open(schema_path, 'r') as fp:
|
||||
schema = json.load(fp)
|
||||
|
||||
for obj in schema['objects']:
|
||||
for field in obj['fields']:
|
||||
field['id'] = field.get('id', 0)
|
||||
field['type']['base_type'] = type_aliases.get(field['type']['base_type'], field['type']['base_type'])
|
||||
if 'element' in field['type']:
|
||||
field['type']['element'] = type_aliases.get(field['type']['element'], field['type']['element'])
|
||||
field['type']['index'] = field['type'].get('index', -1)
|
||||
field['py_type'] = py_types[field['type']['base_type']]
|
||||
if 'default_integer' in field:
|
||||
if field['py_type'] == 'bool':
|
||||
field['default'] = bool(field['default_integer'])
|
||||
else:
|
||||
field['default'] = field['default_integer']
|
||||
elif 'default_real' in field:
|
||||
field['default'] = field['default_real']
|
||||
else:
|
||||
field['default'] = defaults[field['type']['base_type']]
|
||||
|
||||
imports = {}
|
||||
|
||||
root_file = '//' + os.path.basename(args.path)
|
||||
namespace = None
|
||||
for obj in schema['objects'] + schema['enums']:
|
||||
obj['emit'] = obj['declaration_file'] == root_file
|
||||
if '.' in obj['name']:
|
||||
assert namespace is None or obj['name'].rsplit('.', 1)[0] == namespace, obj['name']
|
||||
namespace, obj['name'] = obj['name'].rsplit('.', 1)
|
||||
if obj['declaration_file'] != root_file:
|
||||
assert obj['declaration_file'].startswith('//')
|
||||
assert obj['declaration_file'].endswith('.fbs')
|
||||
assert '/' not in obj['declaration_file'][2:-4]
|
||||
mod = '.' + obj['declaration_file'][2:-4] + '_generated'
|
||||
imports.setdefault(mod, []).append(obj['name'])
|
||||
|
||||
schema['imports'] = [(m, sorted(s)) for m, s in imports.items()]
|
||||
|
||||
with open(os.path.join(os.path.dirname(__file__), 'fbs.jinja2'), 'r') as fp:
|
||||
template = jinja2.Template(fp.read())
|
||||
out = template.render(
|
||||
schema=schema,
|
||||
)
|
||||
|
||||
out_path = os.path.join(args.output, base_name + '_generated.py')
|
||||
os.makedirs(os.path.dirname(out_path), exist_ok=True)
|
||||
with open(out_path, 'w') as fp:
|
||||
fp.write(out)
|
||||
|
||||
|
||||
def main(argv):
|
||||
argparser = argparse.ArgumentParser()
|
||||
argparser.add_argument('--flatc', default='flatc')
|
||||
argparser.add_argument('--output', '-o', default='.')
|
||||
argparser.add_argument('path')
|
||||
args = argparser.parse_args(argv[1:])
|
||||
|
||||
flatc_path = shutil.which(args.flatc)
|
||||
if flatc_path is None:
|
||||
sys.stderr.write("{} is not a valid executable.\n".format(args.flatc))
|
||||
sys.exit(1)
|
||||
|
||||
p = subprocess.run([flatc_path, '--version'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
if p.returncode:
|
||||
sys.stderr.write("'{} --version' failed.\n".format(flatc_path))
|
||||
sys.exit(1)
|
||||
flatc_version_str = p.stdout.decode('ascii', 'ignore').strip()
|
||||
m = re.match(r'flatc version ([.\d]+)$', flatc_version_str)
|
||||
if not m:
|
||||
sys.stderr.write("{} does not look like the flatc compiler.\n".format(flatc_path))
|
||||
sys.exit(1)
|
||||
flatc_version = tuple(int(p) for p in m.group(1).split('.'))
|
||||
if flatc_version < MIN_FLATC_VERSION:
|
||||
sys.stderr.write("Need flatc V{}, found V{}.\n".format('.'.join(str(p) for p in MIN_FLATC_VERSION), '.'.join(str(p) for p in flatc_version)))
|
||||
sys.exit(1)
|
||||
|
||||
base_name = os.path.splitext(os.path.basename(args.path))[0]
|
||||
|
||||
cmd = [
|
||||
flatc_path,
|
||||
'--binary',
|
||||
'--schema',
|
||||
'--bfbs-builtins',
|
||||
'--bfbs-comments',
|
||||
#'--bfbs-filenames', ctx.top_dir,
|
||||
#'--include-prefix', self.inputs[0].parent.relpath(),
|
||||
'-o', args.output,
|
||||
args.path,
|
||||
]
|
||||
subprocess.run(cmd, check=True)
|
||||
|
||||
bfbs_path = os.path.join(args.output, base_name + '.bfbs')
|
||||
assert os.path.isfile(bfbs_path), bfbs_path
|
||||
|
||||
schema_path = os.path.join(os.path.dirname(__file__), 'reflection.fbs')
|
||||
assert os.path.isfile(schema_path), schema_path
|
||||
|
||||
cmd = [
|
||||
flatc_path,
|
||||
'--json',
|
||||
'--strict-json',
|
||||
'-o', args.output,
|
||||
schema_path,
|
||||
'--',
|
||||
bfbs_path,
|
||||
]
|
||||
subprocess.run(cmd, check=True)
|
||||
|
||||
json_path = os.path.join(args.output, base_name + '.json')
|
||||
assert os.path.isfile(json_path), json_path
|
||||
|
||||
gen(args, base_name, json_path)
|
||||
|
||||
return 0
|
||||
|
||||
def run():
|
||||
main(sys.argv)
|
||||
@ -1,145 +0,0 @@
|
||||
// This schema defines objects that represent a parsed schema, like
|
||||
// the binary version of a .fbs file.
|
||||
// This could be used to operate on unknown FlatBuffers at runtime.
|
||||
// It can even ... represent itself (!)
|
||||
|
||||
namespace reflection;
|
||||
|
||||
// These must correspond to the enum in idl.h.
|
||||
enum BaseType : byte {
|
||||
None,
|
||||
UType,
|
||||
Bool,
|
||||
Byte,
|
||||
UByte,
|
||||
Short,
|
||||
UShort,
|
||||
Int,
|
||||
UInt,
|
||||
Long,
|
||||
ULong,
|
||||
Float,
|
||||
Double,
|
||||
String,
|
||||
Vector,
|
||||
Obj, // Used for tables & structs.
|
||||
Union,
|
||||
Array,
|
||||
|
||||
// Add any new type above this value.
|
||||
MaxBaseType
|
||||
}
|
||||
|
||||
table Type {
|
||||
base_type:BaseType;
|
||||
element:BaseType = None; // Only if base_type == Vector
|
||||
// or base_type == Array.
|
||||
index:int = -1; // If base_type == Object, index into "objects" below.
|
||||
// If base_type == Union, UnionType, or integral derived
|
||||
// from an enum, index into "enums" below.
|
||||
fixed_length:uint16 = 0; // Only if base_type == Array.
|
||||
}
|
||||
|
||||
table KeyValue {
|
||||
key:string (required, key);
|
||||
value:string;
|
||||
}
|
||||
|
||||
table EnumVal {
|
||||
name:string (required);
|
||||
value:long (key);
|
||||
object:Object (deprecated);
|
||||
union_type:Type;
|
||||
documentation:[string];
|
||||
}
|
||||
|
||||
table Enum {
|
||||
name:string (required, key);
|
||||
values:[EnumVal] (required); // In order of their values.
|
||||
is_union:bool = false;
|
||||
underlying_type:Type (required);
|
||||
attributes:[KeyValue];
|
||||
documentation:[string];
|
||||
/// File that this Enum is declared in.
|
||||
declaration_file: string;
|
||||
}
|
||||
|
||||
table Field {
|
||||
name:string (required, key);
|
||||
type:Type (required);
|
||||
id:ushort;
|
||||
offset:ushort; // Offset into the vtable for tables, or into the struct.
|
||||
default_integer:long = 0;
|
||||
default_real:double = 0.0;
|
||||
deprecated:bool = false;
|
||||
required:bool = false;
|
||||
key:bool = false;
|
||||
attributes:[KeyValue];
|
||||
documentation:[string];
|
||||
optional:bool = false;
|
||||
}
|
||||
|
||||
table Object { // Used for both tables and structs.
|
||||
name:string (required, key);
|
||||
fields:[Field] (required); // Sorted.
|
||||
is_struct:bool = false;
|
||||
minalign:int;
|
||||
bytesize:int; // For structs.
|
||||
attributes:[KeyValue];
|
||||
documentation:[string];
|
||||
/// File that this Object is declared in.
|
||||
declaration_file: string;
|
||||
}
|
||||
|
||||
table RPCCall {
|
||||
name:string (required, key);
|
||||
request:Object (required); // must be a table (not a struct)
|
||||
response:Object (required); // must be a table (not a struct)
|
||||
attributes:[KeyValue];
|
||||
documentation:[string];
|
||||
}
|
||||
|
||||
table Service {
|
||||
name:string (required, key);
|
||||
calls:[RPCCall];
|
||||
attributes:[KeyValue];
|
||||
documentation:[string];
|
||||
/// File that this Service is declared in.
|
||||
declaration_file: string;
|
||||
}
|
||||
|
||||
/// New schema language features that are not supported by old code generators.
|
||||
enum AdvancedFeatures : ulong (bit_flags) {
|
||||
AdvancedArrayFeatures,
|
||||
AdvancedUnionFeatures,
|
||||
OptionalScalars,
|
||||
DefaultVectorsAndStrings,
|
||||
}
|
||||
|
||||
/// File specific information.
|
||||
/// Symbols declared within a file may be recovered by iterating over all
|
||||
/// symbols and examining the `declaration_file` field.
|
||||
table SchemaFile {
|
||||
/// Filename, relative to project root.
|
||||
filename:string (required, key);
|
||||
/// Names of included files, relative to project root.
|
||||
included_filenames:[string];
|
||||
}
|
||||
|
||||
table Schema {
|
||||
objects:[Object] (required); // Sorted.
|
||||
enums:[Enum] (required); // Sorted.
|
||||
file_ident:string;
|
||||
file_ext:string;
|
||||
root_table:Object;
|
||||
services:[Service]; // Sorted.
|
||||
advanced_features:AdvancedFeatures;
|
||||
/// All the files used in this compilation. Files are relative to where
|
||||
/// flatc was invoked.
|
||||
fbs_files:[SchemaFile]; // Sorted.
|
||||
}
|
||||
|
||||
root_type Schema;
|
||||
|
||||
file_identifier "BFBS";
|
||||
file_extension "bfbs";
|
||||
@ -1,416 +0,0 @@
|
||||
import enum
|
||||
import importlib.util
|
||||
import os.path
|
||||
import textwrap
|
||||
|
||||
import flatbuffers
|
||||
|
||||
import flatpy.main
|
||||
|
||||
def compile_fbs(*, outdir, name, contents):
|
||||
assert name.endswith('.fbs')
|
||||
with open(os.path.join(outdir, name), 'w') as fp:
|
||||
fp.write(textwrap.dedent(contents))
|
||||
|
||||
try:
|
||||
rc = flatpy.main.main(['flatpy', '-o', str(outdir), os.path.join(outdir, name)])
|
||||
finally:
|
||||
print("---- schema ----------------------------------------------")
|
||||
with open(os.path.join(outdir, name[:-4] + '.json'), 'r') as fp:
|
||||
for lineno, line in enumerate(fp, 1):
|
||||
print('{:4d} {}'.format(lineno, line.rstrip()))
|
||||
|
||||
assert rc == 0
|
||||
|
||||
mod_name = name[:-4] + '_generated'
|
||||
mod_path = os.path.join(outdir, mod_name + '.py')
|
||||
assert os.path.isfile(mod_path), mod_path
|
||||
|
||||
print("---- {} ----------------------------------------------".format(mod_name))
|
||||
with open(mod_path, 'r') as fp:
|
||||
for lineno, line in enumerate(fp, 1):
|
||||
print('{:4d} {}'.format(lineno, line.rstrip()))
|
||||
|
||||
spec = importlib.util.spec_from_file_location(mod_name, mod_path)
|
||||
mod = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(mod)
|
||||
return mod
|
||||
|
||||
|
||||
def test_simple_fields(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
table Test {
|
||||
string_field: string;
|
||||
int8_field: int8;
|
||||
ubyte_field: ubyte;
|
||||
uint8_field: uint8;
|
||||
bool_field: bool;
|
||||
short_field: short;
|
||||
int16_field: int16;
|
||||
ushort_field: ushort;
|
||||
uint16_field: uint16;
|
||||
int_field: int;
|
||||
int32_field: int32;
|
||||
uint_field: uint;
|
||||
uint32_field: uint32;
|
||||
float_field: float;
|
||||
float32_field: float32;
|
||||
long_field: long;
|
||||
int64_field: int64;
|
||||
ulong_field: ulong;
|
||||
uint64_field: uint64;
|
||||
double_field: double;
|
||||
float64_field: float64;
|
||||
}
|
||||
''')
|
||||
|
||||
assert isinstance(mod.Test, type)
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTest(
|
||||
bld,
|
||||
string_field="hello",
|
||||
int8_field=12,
|
||||
ubyte_field=13,
|
||||
uint8_field=14,
|
||||
bool_field=True,
|
||||
short_field=15,
|
||||
int16_field=16,
|
||||
ushort_field=17,
|
||||
uint16_field=18,
|
||||
int_field=19,
|
||||
int32_field=20,
|
||||
uint_field=21,
|
||||
uint32_field=22,
|
||||
float_field=2.0,
|
||||
float32_field=3.0,
|
||||
long_field=23,
|
||||
int64_field=24,
|
||||
ulong_field=25,
|
||||
uint64_field=26,
|
||||
double_field=4.0,
|
||||
float64_field=5.0,
|
||||
)
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
assert t.string_field == "hello"
|
||||
assert t.int8_field == 12
|
||||
assert t.ubyte_field == 13
|
||||
assert t.uint8_field == 14
|
||||
assert t.bool_field == True
|
||||
assert t.short_field == 15
|
||||
assert t.int16_field == 16
|
||||
assert t.ushort_field == 17
|
||||
assert t.uint16_field == 18
|
||||
assert t.int_field == 19
|
||||
assert t.int32_field == 20
|
||||
assert t.uint_field == 21
|
||||
assert t.uint32_field == 22
|
||||
assert t.float_field == 2.0
|
||||
assert t.float32_field == 3.0
|
||||
assert t.long_field == 23
|
||||
assert t.int64_field == 24
|
||||
assert t.ulong_field == 25
|
||||
assert t.uint64_field == 26
|
||||
assert t.double_field == 4.0
|
||||
assert t.float64_field == 5.0
|
||||
|
||||
|
||||
def test_string_vector(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
table Test {
|
||||
strings: [string];
|
||||
}
|
||||
''')
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTest(
|
||||
bld,
|
||||
strings=["hello", "world"],
|
||||
)
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
# TODO: Currently it builds a new list for each attribute access. Replace this with a (cached)
|
||||
# proxy object, which implements the list interface.
|
||||
assert t.strings == ["hello", "world"]
|
||||
|
||||
|
||||
def test_enum_vector(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
enum T : int { a, b, c }
|
||||
table Test {
|
||||
enums: [T];
|
||||
}
|
||||
''')
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTest(
|
||||
bld,
|
||||
enums=[mod.T.c, mod.T.a],
|
||||
)
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
assert t.enums == [mod.T.c, mod.T.a]
|
||||
|
||||
|
||||
def test_float_vector(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
table Test {
|
||||
values: [float];
|
||||
}
|
||||
''')
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTest(
|
||||
bld,
|
||||
values=[1.0, 2.0, 3.0],
|
||||
)
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
assert t.values == [1.0, 2.0, 3.0]
|
||||
|
||||
|
||||
def test_enum(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
enum Some : int {
|
||||
Val1,
|
||||
Val2,
|
||||
Val3
|
||||
}
|
||||
|
||||
table Test {
|
||||
some : Some;
|
||||
}
|
||||
''')
|
||||
|
||||
assert issubclass(mod.Some, enum.IntEnum)
|
||||
assert mod.Some.Val1 == 0
|
||||
assert mod.Some.Val2 == 1
|
||||
assert mod.Some.Val3 == 2
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTest(
|
||||
bld,
|
||||
some=mod.Some.Val2,
|
||||
)
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
# TODO: t.some should be an IntEnum instance, not a plain int.
|
||||
# Problem: the json file does not contain a reference to the enum type for the field, just the numeric base type.
|
||||
#assert isinstance(t.some, mod.Some)
|
||||
assert t.some == mod.Some.Val2
|
||||
|
||||
|
||||
def test_table_ref(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
table A {
|
||||
a1 : string;
|
||||
}
|
||||
|
||||
table Test {
|
||||
a : A;
|
||||
}
|
||||
''')
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTest(
|
||||
bld,
|
||||
a=mod.CreateA(
|
||||
bld,
|
||||
a1="hello"
|
||||
),
|
||||
)
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
assert isinstance(t.a, mod.A)
|
||||
assert t.a.a1 == "hello"
|
||||
|
||||
|
||||
def test_table_vector(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
table Elem {
|
||||
a: string;
|
||||
b: int;
|
||||
}
|
||||
table Test {
|
||||
x: Elem;
|
||||
v: [Elem];
|
||||
}
|
||||
''')
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTest(
|
||||
bld,
|
||||
v=[mod.CreateElem(bld, a="A", b=1),
|
||||
mod.CreateElem(bld, a="B", b=2)],
|
||||
)
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
# TODO: Currently it builds a new list for each attribute access. Replace this with a (cached)
|
||||
# proxy object, which implements the list interface.
|
||||
assert len(t.v) == 2
|
||||
assert isinstance(t.v[0], mod.Elem)
|
||||
assert t.v[0].a == "A"
|
||||
assert t.v[0].b == 1
|
||||
assert t.v[1].a == "B"
|
||||
assert t.v[1].b == 2
|
||||
|
||||
|
||||
def test_table_union(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
table A {
|
||||
a1 : string;
|
||||
}
|
||||
|
||||
table B {
|
||||
b1 : string;
|
||||
}
|
||||
|
||||
union Payload {
|
||||
a : A,
|
||||
b : B,
|
||||
}
|
||||
|
||||
table Test {
|
||||
payload : Payload;
|
||||
}
|
||||
''')
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTest(
|
||||
bld,
|
||||
payload_type=mod.Payload.a,
|
||||
payload=mod.CreateA(
|
||||
bld,
|
||||
a1="hello"
|
||||
),
|
||||
)
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
assert t.payload_type == mod.Payload.a
|
||||
a = mod.A(t.payload)
|
||||
assert a.a1 == "hello"
|
||||
|
||||
|
||||
def test_from_json(tmpdir):
|
||||
mod = compile_fbs(
|
||||
outdir=tmpdir,
|
||||
name='test.fbs',
|
||||
contents='''\
|
||||
table A {
|
||||
a1 : string;
|
||||
a2 : int;
|
||||
a3 : bool;
|
||||
}
|
||||
|
||||
table B {
|
||||
b1 : string;
|
||||
}
|
||||
|
||||
enum E : int { X, Y, Z }
|
||||
|
||||
table Test {
|
||||
a : A;
|
||||
avec : [A];
|
||||
e : E;
|
||||
evec : [E];
|
||||
strvec : [string];
|
||||
intvec : [int];
|
||||
}
|
||||
''')
|
||||
|
||||
bld = flatbuffers.Builder()
|
||||
offset = mod.CreateTestFromJSON(bld, {
|
||||
'a': {
|
||||
'a1': 'hello',
|
||||
'a2': 23
|
||||
},
|
||||
'avec': [
|
||||
{'a1': 'hello1'},
|
||||
{'a1': 'hello2'},
|
||||
],
|
||||
'e': 'X',
|
||||
'evec': ['Y', 'Z'],
|
||||
'strvec': ['aa', 'bb'],
|
||||
'intvec': [3, 4, 5]
|
||||
})
|
||||
bld.Finish(offset)
|
||||
buf = bld.Output()
|
||||
|
||||
t = mod.Test(buf)
|
||||
assert t.a.a1 == "hello"
|
||||
assert t.a.a2 == 23
|
||||
assert t.avec[0].a1 == "hello1"
|
||||
assert t.avec[1].a1 == "hello2"
|
||||
assert t.e == mod.E.X
|
||||
assert t.evec == [mod.E.Y, mod.E.Z]
|
||||
assert t.strvec == ['aa', 'bb']
|
||||
assert t.intvec == [3, 4, 5]
|
||||
|
||||
|
||||
# def test_imports(tmpdir):
|
||||
# with open(os.path.join(tmpdir, '__init__.py'), 'w') as fp:
|
||||
# pass
|
||||
|
||||
# mod = compile_fbs(
|
||||
# outdir=tmpdir,
|
||||
# name='imported.fbs',
|
||||
# contents='''\
|
||||
# table I {
|
||||
# a : string;
|
||||
# }
|
||||
|
||||
# enum E : int { X, Y, Z }
|
||||
# ''')
|
||||
|
||||
# mod = compile_fbs(
|
||||
# outdir=tmpdir,
|
||||
# name='test.fbs',
|
||||
# contents='''\
|
||||
# include "imported.fbs";
|
||||
|
||||
# table A {
|
||||
# i : I;
|
||||
# e : E;
|
||||
# }
|
||||
# ''')
|
||||
@ -1,37 +0,0 @@
|
||||
from setuptools import setup
|
||||
|
||||
setup(
|
||||
name = 'flatpy',
|
||||
version = '0.1',
|
||||
author = 'Ben Niemann',
|
||||
author_email = 'pink@odahoda.de',
|
||||
# url = 'TODO',
|
||||
# license = 'TODO',
|
||||
classifiers = [
|
||||
'Development Status :: 2 - Pre-Alpha',
|
||||
#'Environment :: X11 Applications :: Qt',
|
||||
#'Intended Audience :: End Users/Desktop',
|
||||
# TODO: 'License :: OSI Approved :: ',
|
||||
#'Natural Language :: English',
|
||||
#'Operating System :: POSIX :: Linux',
|
||||
#'Programming Language :: Cython',
|
||||
'Programming Language :: Python :: 3 :: Only',
|
||||
#'Programming Language :: Python :: Implementation :: CPython',
|
||||
],
|
||||
packages = ['flatpy'],
|
||||
package_data={
|
||||
'flatpy': [
|
||||
'reflection.fbs',
|
||||
'fbs.jinja2',
|
||||
]
|
||||
},
|
||||
entry_points = {
|
||||
'console_scripts': [
|
||||
'flatpy = flatpy.main:run',
|
||||
],
|
||||
},
|
||||
install_requires=[
|
||||
'flatbuffers>=2.0.0',
|
||||
'jinja2>=3.0',
|
||||
],
|
||||
)
|
||||
Loading…
Reference in new issue