13 changed files with 11 additions and 1035 deletions
@ -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/ |
|||
|
|||
@ -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