From 9bf8f07481b42658ef09cbf69ef33d0e86e377a8 Mon Sep 17 00:00:00 2001 From: Erik Lundell Date: Thu, 4 Jun 2026 18:01:56 +0200 Subject: [PATCH] Implement direct serialization of .bpte:s This patch is heavily inspired by https://github.com/pytorch/executorch/pull/17333 Similarly to the old serialization of pte:s, bundled program serialization went through a program -> string json -> flatbuffer path, which is heavily inefficient. As in the PR above, generate python flatbuffer bindings from the fbs schema and use them to cut out the json step. Checked in flatbuffer bindings and fbs schema coherence is enforced by the validate_flatbuffer_gen job. e6586533af Testing: Tested by devtools/bundled_program/test/test_end2end.py, Additionally, did the following benchmark locally: /usr/bin/time -v -- aot_arm_compiler.py --delegate --bundleio -t vgf [args] Time metric: Elapsed (wall clock) time Memory metric: Maximum resident set size Model Baseline (s / MiB) With-patch (s / MiB) Speed-up Relative memory same.bpte bpte size (MiB) --------- ------------------- --------------------- -------- --------------- -------- --------- mv2 31.36 / 1349.7 22.37 / 845.5 1.40x 0.63x (-37.4%) yes 13.91 resnet50 128.57 / 10380.9 28.24 / 2003.4 4.55x 0.19x (-80.7%) yes 97.99 w2l 730.23 / 12102.9 15.85 / 2376.2 46.07x 0.20x (-80.4%) yes 131.45 deit_tiny 87.57 / 2669.5 70.23 / 1037.6 1.25x 0.39x (-61.1%) yes 22.88 Notice that the peak memory consumption is still a factor 20-50 x the final artifact size. Signed-off-by: Erik Lundell Change-Id: I98d24ad8e3d2537567e8f4b873d5aacae619eaf5 --- .flake8 | 1 + .github/workflows/validate_flatbuffer_gen.yml | 16 +- .lintrunner.toml | 2 + backends/arm/scripts/pre-push | 2 +- devtools/bundled_program/schema/README.md | 10 + devtools/bundled_program/serialize/BUCK | 3 +- .../bundled_program/serialize/__init__.py | 184 +++++++++++- .../serialize/generate_bundled_program.py | 174 ++++++++++++ .../serialize/generated/__init__.py | 9 + .../bundled_program_flatbuffer/Bool.py | 92 ++++++ .../BundledMethodTestCase.py | 194 +++++++++++++ .../BundledMethodTestSuite.py | 158 +++++++++++ .../BundledProgram.py | 212 ++++++++++++++ .../bundled_program_flatbuffer/Double.py | 92 ++++++ .../bundled_program_flatbuffer/Int.py | 92 ++++++ .../bundled_program_flatbuffer/Tensor.py | 267 ++++++++++++++++++ .../bundled_program_flatbuffer/Value.py | 125 ++++++++ .../bundled_program_flatbuffer/ValueUnion.py | 29 ++ .../bundled_program_flatbuffer/__init__.py | 23 ++ .../executorch_flatbuffer/ScalarType.py | 28 ++ .../executorch_flatbuffer/__init__.py | 7 + 21 files changed, 1713 insertions(+), 7 deletions(-) create mode 100644 devtools/bundled_program/serialize/generate_bundled_program.py create mode 100644 devtools/bundled_program/serialize/generated/__init__.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Bool.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledMethodTestCase.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledMethodTestSuite.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledProgram.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Double.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Int.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Tensor.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Value.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/ValueUnion.py create mode 100644 devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/__init__.py create mode 100644 devtools/bundled_program/serialize/generated/executorch_flatbuffer/ScalarType.py create mode 100644 devtools/bundled_program/serialize/generated/executorch_flatbuffer/__init__.py diff --git a/.flake8 b/.flake8 index fc9feb45d8b..ffb419da1e4 100644 --- a/.flake8 +++ b/.flake8 @@ -75,6 +75,7 @@ exclude = ./configurations, ./docs, ./exir/_serialize/generated/executorch_flatbuffer, + ./devtools/bundled_program/serialize/generated, ./third_party, *.pyi diff --git a/.github/workflows/validate_flatbuffer_gen.yml b/.github/workflows/validate_flatbuffer_gen.yml index 96eeda95e04..6c0455784c6 100644 --- a/.github/workflows/validate_flatbuffer_gen.yml +++ b/.github/workflows/validate_flatbuffer_gen.yml @@ -5,7 +5,9 @@ on: pull_request: paths: - "schema/**" - - "exir/_serialize/generated/executorch_flatbuffer/**" + - "devtools/bundled_program/schema/**" + - "exir/_serialize/generated/**" + - "devtools/bundled_program/serialize/generated/**" jobs: exir-flatbuffer: @@ -33,3 +35,15 @@ jobs: echo "Please run 'python exir/_serialize/generate_program.py' to regenerate the files and commit the changes." exit 1 fi + + - name: Generate bundled program flatbuffer Python + run: python devtools/bundled_program/serialize/generate_bundled_program.py + + - name: Validate bundled_program_flatbuffer is unchanged + run: | + git add -A devtools/bundled_program/serialize/generated + if ! git diff --cached --quiet -- devtools/bundled_program/serialize/generated; then + echo "Error: bundled_program_flatbuffer has uncommitted changes." + echo "Please run 'python devtools/bundled_program/serialize/generate_bundled_program.py' to regenerate the files and commit the changes." + exit 1 + fi diff --git a/.lintrunner.toml b/.lintrunner.toml index 056b25ff541..1422ea8a0de 100644 --- a/.lintrunner.toml +++ b/.lintrunner.toml @@ -9,6 +9,7 @@ exclude_patterns = [ '.github/scripts/**', 'exir/serde/**', 'exir/_serialize/generated/executorch_flatbuffer/**', + 'devtools/bundled_program/serialize/generated/**', ] command = [ 'python', @@ -41,6 +42,7 @@ exclude_patterns = [ '**/third-party/**', 'exir/serde/**', 'exir/_serialize/generated/executorch_flatbuffer/**', + 'devtools/bundled_program/serialize/generated/**', ] command = [ 'python', diff --git a/backends/arm/scripts/pre-push b/backends/arm/scripts/pre-push index 1aa51a8f9ac..9c324e0d784 100755 --- a/backends/arm/scripts/pre-push +++ b/backends/arm/scripts/pre-push @@ -177,7 +177,7 @@ for COMMIT in ${COMMITS}; do for committed_file in "${license_files[@]}"; do # Skip files with certain extensions case "$committed_file" in - *.md|*.md.in|*.json|*.yml|*.yaml|*.cmake|*.patch|.gitignore|*.bzl|BUCK|*/BUCK|TARGETS|*/TARGETS) + *.md|*.md.in|*.json|*.yml|*.yaml|*.cmake|*.patch|.gitignore|*.bzl|BUCK|*/BUCK|TARGETS|*/TARGETS|*/generated/*) echo -e "${INFO} Skipping license check for ${committed_file} (excluded extension)" continue ;; diff --git a/devtools/bundled_program/schema/README.md b/devtools/bundled_program/schema/README.md index 096ab10fb57..c161958f189 100644 --- a/devtools/bundled_program/schema/README.md +++ b/devtools/bundled_program/schema/README.md @@ -4,3 +4,13 @@ and other useful info together for verifying the correctness of ExecuTorch progr ## Rules to ensure forward/backward compatibility Please check the rules in [here](../../../schema/README.md) for more info. + + +## Regenerating generated code + +Schema changes require regenerating the Python bindings in +`devtools/bundled_program/serialize/generated` and committing the updated files. From the repo root: + +```sh +python devtools/bundled_program/serialize/generate_bundled_program.py +``` \ No newline at end of file diff --git a/devtools/bundled_program/serialize/BUCK b/devtools/bundled_program/serialize/BUCK index ae920d1e4c2..89a8122503c 100644 --- a/devtools/bundled_program/serialize/BUCK +++ b/devtools/bundled_program/serialize/BUCK @@ -9,7 +9,7 @@ fbcode_target(_kind = runtime.python_library, name = "lib", srcs = [ "__init__.py", - ], + ] + glob(["generated/**/*.py"]), resources = { "//executorch/devtools/bundled_program/schema:bundled_program_schema.fbs": "bundled_program_schema.fbs", "//executorch/devtools/bundled_program/schema:scalar_type.fbs": "scalar_type.fbs", @@ -19,6 +19,7 @@ fbcode_target(_kind = runtime.python_library, # Please ask before changing this. visibility = ["PUBLIC"], deps = [ + "fbsource//third-party/pypi/flatbuffers:flatbuffers", "fbsource//third-party/pypi/setuptools:setuptools", "//executorch/devtools/bundled_program/schema:bundled_program_schema_py", "//executorch/exir/_serialize:lib", diff --git a/devtools/bundled_program/serialize/__init__.py b/devtools/bundled_program/serialize/__init__.py index ceba7670910..50c6b5768ce 100644 --- a/devtools/bundled_program/serialize/__init__.py +++ b/devtools/bundled_program/serialize/__init__.py @@ -1,6 +1,6 @@ # Copyright (c) Meta Platforms, Inc. and affiliates. # All rights reserved. -# Copyright 2025 Arm Limited and/or its affiliates. +# Copyright 2025-2026 Arm Limited and/or its affiliates. # # This source code is licensed under the BSD-style license found in the # LICENSE file in the root directory of this source tree. @@ -9,23 +9,62 @@ # TODO(T138924864): Refactor to unify the serialization for bundled program and executorch program. +import functools import importlib.resources as _resources import json import os +import re import tempfile +from typing import Any import executorch.devtools.bundled_program.schema as bp_schema import executorch.devtools.bundled_program.serialize as serialization_package + +import flatbuffers # pyre-ignore[21] from executorch.devtools.bundled_program.core import BundledProgram +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import ( + Bool as _Bool, + BundledMethodTestCase as _BundledMethodTestCase, + BundledMethodTestSuite as _BundledMethodTestSuite, + BundledProgram as _BundledProgram, + Double as _Double, + Int as _Int, + Tensor as _Tensor, + Value as _Value, + ValueUnion as _ValueUnion, +) from executorch.exir._serialize._dataclass import _DataclassEncoder, _json_to_dataclass from executorch.exir._serialize._flatbuffer import _flatc_compile, _flatc_decompile +from executorch.exir._serialize._flatbuffer_program import ( + _coerce_bytes, + _create_aligned_byte_vector, +) # The prefix of schema files used for bundled program BUNDLED_PROGRAM_SCHEMA_NAME = "bundled_program_schema" SCALAR_TYPE_SCHEMA_NAME = "scalar_type" +@functools.lru_cache(maxsize=1) +def _bundled_program_file_identifier() -> bytes: + schema = _resources.read_binary( + serialization_package, f"{BUNDLED_PROGRAM_SCHEMA_NAME}.fbs" + ) + match = re.search(rb'file_identifier\s+"([^"]+)"', schema) + if match is None: + raise ValueError( + f"Missing file_identifier in {BUNDLED_PROGRAM_SCHEMA_NAME}.fbs" + ) + file_identifier = match.group(1) + if len(file_identifier) != 4: + raise ValueError( + f"Invalid file_identifier length {len(file_identifier)} " + f"in {BUNDLED_PROGRAM_SCHEMA_NAME}.fbs" + ) + return file_identifier + + def write_schema(d: str, schema_name: str) -> None: schema_path = os.path.join(d, "{}.fbs".format(schema_name)) with open(schema_path, "wb") as schema_file: @@ -78,6 +117,145 @@ def convert_from_flatbuffer(program_flatbuffer: bytes) -> bytes: return output_file.read() +def _pack_tensor(self: Any, builder: Any) -> int: + if self.sizes is not None: + _Tensor.TensorStartSizesVector(builder, len(self.sizes)) + for i in reversed(range(len(self.sizes))): + builder.PrependInt32(self.sizes[i]) + sizes = builder.EndVector() + if self.data is not None: + data = _create_aligned_byte_vector(builder, _coerce_bytes(self.data), 16) + if self.dimOrder is not None: + dim_order = _create_aligned_byte_vector( + builder, _coerce_bytes(self.dimOrder), 1 + ) + + _Tensor.TensorStart(builder) + _Tensor.TensorAddScalarType(builder, self.scalarType) + if self.sizes is not None: + _Tensor.TensorAddSizes(builder, sizes) + if self.data is not None: + _Tensor.TensorAddData(builder, data) + if self.dimOrder is not None: + _Tensor.TensorAddDimOrder(builder, dim_order) + return _Tensor.TensorEnd(builder) + + +def _pack_bundled_program(self: Any, builder: Any) -> int: + if self.methodTestSuites is not None: + method_test_suites_list = [ + method_test_suite.Pack(builder) + for method_test_suite in self.methodTestSuites + ] + _BundledProgram.BundledProgramStartMethodTestSuitesVector( + builder, len(self.methodTestSuites) + ) + for i in reversed(range(len(self.methodTestSuites))): + builder.PrependUOffsetTRelative(method_test_suites_list[i]) + method_test_suites = builder.EndVector() + if self.program is not None: + program = _create_aligned_byte_vector(builder, _coerce_bytes(self.program), 32) + + _BundledProgram.BundledProgramStart(builder) + _BundledProgram.BundledProgramAddVersion(builder, self.version) + if self.methodTestSuites is not None: + _BundledProgram.BundledProgramAddMethodTestSuites(builder, method_test_suites) + if self.program is not None: + _BundledProgram.BundledProgramAddProgram(builder, program) + return _BundledProgram.BundledProgramEnd(builder) + + +@functools.lru_cache(maxsize=1) +def _install_fast_packers() -> None: + _Tensor.TensorT.Pack = _pack_tensor + _BundledProgram.BundledProgramT.Pack = _pack_bundled_program + + +def _convert_tensor(val: bp_schema.Tensor) -> Any: + result = _Tensor.TensorT() + result.scalarType = int(val.scalar_type) + result.sizes = list(val.sizes) + result.data = _coerce_bytes(val.data) + result.dimOrder = _coerce_bytes(val.dim_order) + return result + + +def _convert_int(val: bp_schema.Int) -> Any: + result = _Int.IntT() + result.intVal = val.int_val + return result + + +def _convert_bool(val: bp_schema.Bool) -> Any: + result = _Bool.BoolT() + result.boolVal = val.bool_val + return result + + +def _convert_double(val: bp_schema.Double) -> Any: + result = _Double.DoubleT() + result.doubleVal = val.double_val + return result + + +def _convert_value_union(val: bp_schema.ValueUnion) -> tuple[int, Any]: + if isinstance(val, bp_schema.Tensor): + return _ValueUnion.ValueUnion.Tensor, _convert_tensor(val) + if isinstance(val, bp_schema.Int): + return _ValueUnion.ValueUnion.Int, _convert_int(val) + if isinstance(val, bp_schema.Bool): + return _ValueUnion.ValueUnion.Bool, _convert_bool(val) + if isinstance(val, bp_schema.Double): + return _ValueUnion.ValueUnion.Double, _convert_double(val) + return _ValueUnion.ValueUnion.NONE, None + + +def _convert_value(val: bp_schema.Value) -> Any: + result = _Value.ValueT() + result.valType, result.val = _convert_value_union(val.val) + return result + + +def _convert_method_test_case(val: bp_schema.BundledMethodTestCase) -> Any: + result = _BundledMethodTestCase.BundledMethodTestCaseT() + result.inputs = [_convert_value(value) for value in val.inputs] + result.expectedOutputs = [_convert_value(value) for value in val.expected_outputs] + return result + + +def _convert_method_test_suite(val: bp_schema.BundledMethodTestSuite) -> Any: + result = _BundledMethodTestSuite.BundledMethodTestSuiteT() + result.methodName = val.method_name + result.testCases = [ + _convert_method_test_case(test_case) for test_case in val.test_cases + ] + return result + + +def _convert_bundled_program(val: bp_schema.BundledProgram) -> Any: + result = _BundledProgram.BundledProgramT() + result.version = val.version + result.methodTestSuites = [ + _convert_method_test_suite(suite) for suite in val.method_test_suites + ] + result.program = _coerce_bytes(val.program) + return result + + +def _bundled_program_schema_to_flatbuffer( + bundled_program: bp_schema.BundledProgram, +) -> bytes: + _install_fast_packers() + bundled_program_t = _convert_bundled_program(bundled_program) + builder = flatbuffers.Builder() + bundled_program_offset = bundled_program_t.Pack(builder) + builder.Finish( + bundled_program_offset, + file_identifier=_bundled_program_file_identifier(), + ) + return bytes(builder.Output()) + + # from bundled program to flatbuffer def serialize_from_bundled_program_to_flatbuffer( bundled_program: BundledProgram, @@ -94,9 +272,7 @@ def serialize_from_bundled_program_to_flatbuffer( bundled_program_in_schema = bundled_program.serialize_to_schema() - return convert_to_flatbuffer( - serialize_from_bundled_program_to_json(bundled_program_in_schema) - ) + return _bundled_program_schema_to_flatbuffer(bundled_program_in_schema) # From flatbuffer to bundled program in schema. diff --git a/devtools/bundled_program/serialize/generate_bundled_program.py b/devtools/bundled_program/serialize/generate_bundled_program.py new file mode 100644 index 00000000000..d84a28920b7 --- /dev/null +++ b/devtools/bundled_program/serialize/generate_bundled_program.py @@ -0,0 +1,174 @@ +# Copyright 2026 Arm Limited and/or its affiliates. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +import os +import subprocess +import sys +from pathlib import Path + + +_FLATC_ARGS = [ + "--python", + "--python-typing", + "--gen-object-api", + "--gen-mutable", + "-o", + "devtools/bundled_program/serialize/generated", +] +_PACKAGE_PREFIX = "executorch.devtools.bundled_program.serialize.generated" +_NAMESPACE_PACKAGES = ("bundled_program_flatbuffer", "executorch_flatbuffer") + + +def _repo_root() -> Path: + return Path(__file__).resolve().parents[3] + + +def _flatc_executable() -> str: + return os.getenv("FLATC_EXECUTABLE", "flatc") + + +def _run_flatc(repo_root: Path) -> None: + schema_dir = repo_root / "devtools" / "bundled_program" / "schema" + schema_files = [ + schema_dir / "bundled_program_schema.fbs", + schema_dir / "scalar_type.fbs", + ] + output_dir = repo_root / "devtools" / "bundled_program" / "serialize" / "generated" + output_dir.mkdir(parents=True, exist_ok=True) + + cmd = [_flatc_executable(), *_FLATC_ARGS, *[str(path) for path in schema_files]] + subprocess.run(cmd, check=True, cwd=repo_root) + + +def _rewrite_import_line(line: str, package_name: str) -> str: + package_import = f"from {_PACKAGE_PREFIX} import {package_name}" + from_import_prefix = f"from {_PACKAGE_PREFIX}.{package_name} import " + + if f"from {package_name}" in line: + line = line.replace( + f"from {package_name}", f"from {_PACKAGE_PREFIX}.{package_name}" + ) + stripped = line.lstrip() + if stripped.startswith(f"import {package_name}."): + indent = line[: len(line) - len(stripped)] + remainder = stripped[len(f"import {package_name}.") :] + return f"{indent}{from_import_prefix}{remainder}" + if stripped.startswith(f"import {package_name}"): + indent = line[: len(line) - len(stripped)] + remainder = stripped[len(f"import {package_name}") :] + return f"{indent}{package_import}{remainder}" + return line + + +def _first_import_line(lines: list[str]) -> int: + for index, line in enumerate(lines): + stripped = line.strip() + if not stripped or stripped.startswith("#"): + continue + if stripped.startswith("from __future__ import"): + continue + return index + return len(lines) + + +def _ensure_package_import(contents: str, package_name: str) -> str: + package_import = f"from {_PACKAGE_PREFIX} import {package_name}" + if f"{package_name}." not in contents or package_import in contents: + return contents + + lines = contents.splitlines(keepends=True) + lines.insert(_first_import_line(lines), package_import + "\n") + return "".join(lines) + + +def _rewrite_imports(repo_root: Path) -> int: + generated_dir = ( + repo_root / "devtools" / "bundled_program" / "serialize" / "generated" + ) + updated = 0 + for package_name in _NAMESPACE_PACKAGES: + package_dir = generated_dir / package_name + if not package_dir.is_dir(): + raise SystemExit(f"Expected generated directory at {package_dir}") + + for path in sorted(package_dir.rglob("*.py")): + contents = path.read_text(encoding="utf-8") + new_contents = "".join( + _rewrite_import_line(line, package_name) + for line in contents.splitlines(keepends=True) + ) + new_contents = _ensure_package_import(new_contents, package_name) + + if new_contents != contents: + path.write_text(new_contents, encoding="utf-8") + updated += 1 + return updated + + +def _write_init_files(repo_root: Path) -> int: + generated_dir = ( + repo_root / "devtools" / "bundled_program" / "serialize" / "generated" + ) + generated_dir.mkdir(parents=True, exist_ok=True) + + top_init = generated_dir / "__init__.py" + top_init_contents = [ + "# automatically generated by " + "devtools/bundled_program/serialize/generate_bundled_program.py, " + "do not modify", + "", + "from . import bundled_program_flatbuffer", + "from . import executorch_flatbuffer", + "", + "__all__ = [", + ' "bundled_program_flatbuffer",', + ' "executorch_flatbuffer",', + "]", + "", + ] + top_init.write_text("\n".join(top_init_contents), encoding="utf-8") + + updated = 1 + for package_name in _NAMESPACE_PACKAGES: + package_dir = generated_dir / package_name + if not package_dir.is_dir(): + raise SystemExit(f"Expected generated directory at {package_dir}") + + module_names = sorted( + path.stem for path in package_dir.glob("*.py") if path.name != "__init__.py" + ) + init_file = package_dir / "__init__.py" + init_contents = [ + "# automatically generated by " + "devtools/bundled_program/serialize/generate_bundled_program.py, " + "do not modify", + "", + ] + init_contents.extend(f"from . import {name}" for name in module_names) + init_contents.extend( + [ + "", + "__all__ = [", + *[f' "{name}",' for name in module_names], + "]", + "", + ] + ) + init_file.write_text("\n".join(init_contents), encoding="utf-8") + updated += 1 + return updated + + +def main() -> int: + repo_root = _repo_root() + _run_flatc(repo_root) + updated = _rewrite_imports(repo_root) + updated += _write_init_files(repo_root) + print(f"Updated {updated} file(s).", file=sys.stderr) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/devtools/bundled_program/serialize/generated/__init__.py b/devtools/bundled_program/serialize/generated/__init__.py new file mode 100644 index 00000000000..3f540086eaf --- /dev/null +++ b/devtools/bundled_program/serialize/generated/__init__.py @@ -0,0 +1,9 @@ +# automatically generated by devtools/bundled_program/serialize/generate_bundled_program.py, do not modify + +from . import bundled_program_flatbuffer +from . import executorch_flatbuffer + +__all__ = [ + "bundled_program_flatbuffer", + "executorch_flatbuffer", +] diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Bool.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Bool.py new file mode 100644 index 00000000000..dabf453aab5 --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Bool.py @@ -0,0 +1,92 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +import flatbuffers +from flatbuffers.compat import import_numpy +from typing import Any +np = import_numpy() + +class Bool(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset: int = 0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Bool() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsBool(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def BoolBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x42\x50\x30\x38", size_prefixed=size_prefixed) + + # Bool + def Init(self, buf: bytes, pos: int): + self._tab = flatbuffers.table.Table(buf, pos) + + # Bool + def BoolVal(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def BoolStart(builder: flatbuffers.Builder): + builder.StartObject(1) + +def Start(builder: flatbuffers.Builder): + BoolStart(builder) + +def BoolAddBoolVal(builder: flatbuffers.Builder, boolVal: bool): + builder.PrependBoolSlot(0, boolVal, 0) + +def AddBoolVal(builder: flatbuffers.Builder, boolVal: bool): + BoolAddBoolVal(builder, boolVal) + +def BoolEnd(builder: flatbuffers.Builder) -> int: + return builder.EndObject() + +def End(builder: flatbuffers.Builder) -> int: + return BoolEnd(builder) + + +class BoolT(object): + + # BoolT + def __init__(self): + self.boolVal = False # type: bool + + @classmethod + def InitFromBuf(cls, buf, pos): + bool = Bool() + bool.Init(buf, pos) + return cls.InitFromObj(bool) + + @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, bool): + x = BoolT() + x._UnPack(bool) + return x + + # BoolT + def _UnPack(self, bool): + if bool is None: + return + self.boolVal = bool.BoolVal() + + # BoolT + def Pack(self, builder): + BoolStart(builder) + BoolAddBoolVal(builder, self.boolVal) + bool = BoolEnd(builder) + return bool diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledMethodTestCase.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledMethodTestCase.py new file mode 100644 index 00000000000..a1fb1677ec8 --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledMethodTestCase.py @@ -0,0 +1,194 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +from executorch.devtools.bundled_program.serialize.generated import bundled_program_flatbuffer +import flatbuffers +from flatbuffers.compat import import_numpy +from typing import Any +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer.Value import Value +from typing import Optional +np = import_numpy() + +class BundledMethodTestCase(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset: int = 0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BundledMethodTestCase() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsBundledMethodTestCase(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def BundledMethodTestCaseBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x42\x50\x30\x38", size_prefixed=size_prefixed) + + # BundledMethodTestCase + def Init(self, buf: bytes, pos: int): + self._tab = flatbuffers.table.Table(buf, pos) + + # BundledMethodTestCase + def Inputs(self, j: int) -> Optional[Value]: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = Value() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # BundledMethodTestCase + def InputsLength(self) -> int: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # BundledMethodTestCase + def InputsIsNone(self) -> bool: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # BundledMethodTestCase + def ExpectedOutputs(self, j: int) -> Optional[Value]: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = Value() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # BundledMethodTestCase + def ExpectedOutputsLength(self) -> int: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # BundledMethodTestCase + def ExpectedOutputsIsNone(self) -> bool: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + +def BundledMethodTestCaseStart(builder: flatbuffers.Builder): + builder.StartObject(2) + +def Start(builder: flatbuffers.Builder): + BundledMethodTestCaseStart(builder) + +def BundledMethodTestCaseAddInputs(builder: flatbuffers.Builder, inputs: int): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) + +def AddInputs(builder: flatbuffers.Builder, inputs: int): + BundledMethodTestCaseAddInputs(builder, inputs) + +def BundledMethodTestCaseStartInputsVector(builder, numElems: int) -> int: + return builder.StartVector(4, numElems, 4) + +def StartInputsVector(builder, numElems: int) -> int: + return BundledMethodTestCaseStartInputsVector(builder, numElems) + +def BundledMethodTestCaseAddExpectedOutputs(builder: flatbuffers.Builder, expectedOutputs: int): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(expectedOutputs), 0) + +def AddExpectedOutputs(builder: flatbuffers.Builder, expectedOutputs: int): + BundledMethodTestCaseAddExpectedOutputs(builder, expectedOutputs) + +def BundledMethodTestCaseStartExpectedOutputsVector(builder, numElems: int) -> int: + return builder.StartVector(4, numElems, 4) + +def StartExpectedOutputsVector(builder, numElems: int) -> int: + return BundledMethodTestCaseStartExpectedOutputsVector(builder, numElems) + +def BundledMethodTestCaseEnd(builder: flatbuffers.Builder) -> int: + return builder.EndObject() + +def End(builder: flatbuffers.Builder) -> int: + return BundledMethodTestCaseEnd(builder) + +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Value +try: + from typing import List +except: + pass + +class BundledMethodTestCaseT(object): + + # BundledMethodTestCaseT + def __init__(self): + self.inputs = None # type: List[bundled_program_flatbuffer.Value.ValueT] + self.expectedOutputs = None # type: List[bundled_program_flatbuffer.Value.ValueT] + + @classmethod + def InitFromBuf(cls, buf, pos): + bundledMethodTestCase = BundledMethodTestCase() + bundledMethodTestCase.Init(buf, pos) + return cls.InitFromObj(bundledMethodTestCase) + + @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, bundledMethodTestCase): + x = BundledMethodTestCaseT() + x._UnPack(bundledMethodTestCase) + return x + + # BundledMethodTestCaseT + def _UnPack(self, bundledMethodTestCase): + if bundledMethodTestCase is None: + return + if not bundledMethodTestCase.InputsIsNone(): + self.inputs = [] + for i in range(bundledMethodTestCase.InputsLength()): + if bundledMethodTestCase.Inputs(i) is None: + self.inputs.append(None) + else: + value_ = bundled_program_flatbuffer.Value.ValueT.InitFromObj(bundledMethodTestCase.Inputs(i)) + self.inputs.append(value_) + if not bundledMethodTestCase.ExpectedOutputsIsNone(): + self.expectedOutputs = [] + for i in range(bundledMethodTestCase.ExpectedOutputsLength()): + if bundledMethodTestCase.ExpectedOutputs(i) is None: + self.expectedOutputs.append(None) + else: + value_ = bundled_program_flatbuffer.Value.ValueT.InitFromObj(bundledMethodTestCase.ExpectedOutputs(i)) + self.expectedOutputs.append(value_) + + # BundledMethodTestCaseT + def Pack(self, builder): + if self.inputs is not None: + inputslist = [] + for i in range(len(self.inputs)): + inputslist.append(self.inputs[i].Pack(builder)) + BundledMethodTestCaseStartInputsVector(builder, len(self.inputs)) + for i in reversed(range(len(self.inputs))): + builder.PrependUOffsetTRelative(inputslist[i]) + inputs = builder.EndVector() + if self.expectedOutputs is not None: + expectedOutputslist = [] + for i in range(len(self.expectedOutputs)): + expectedOutputslist.append(self.expectedOutputs[i].Pack(builder)) + BundledMethodTestCaseStartExpectedOutputsVector(builder, len(self.expectedOutputs)) + for i in reversed(range(len(self.expectedOutputs))): + builder.PrependUOffsetTRelative(expectedOutputslist[i]) + expectedOutputs = builder.EndVector() + BundledMethodTestCaseStart(builder) + if self.inputs is not None: + BundledMethodTestCaseAddInputs(builder, inputs) + if self.expectedOutputs is not None: + BundledMethodTestCaseAddExpectedOutputs(builder, expectedOutputs) + bundledMethodTestCase = BundledMethodTestCaseEnd(builder) + return bundledMethodTestCase diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledMethodTestSuite.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledMethodTestSuite.py new file mode 100644 index 00000000000..5f33c7a5107 --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledMethodTestSuite.py @@ -0,0 +1,158 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +from executorch.devtools.bundled_program.serialize.generated import bundled_program_flatbuffer +import flatbuffers +from flatbuffers.compat import import_numpy +from typing import Any +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer.BundledMethodTestCase import BundledMethodTestCase +from typing import Optional +np = import_numpy() + +class BundledMethodTestSuite(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset: int = 0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BundledMethodTestSuite() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsBundledMethodTestSuite(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def BundledMethodTestSuiteBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x42\x50\x30\x38", size_prefixed=size_prefixed) + + # BundledMethodTestSuite + def Init(self, buf: bytes, pos: int): + self._tab = flatbuffers.table.Table(buf, pos) + + # BundledMethodTestSuite + def MethodName(self) -> Optional[str]: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # BundledMethodTestSuite + def TestCases(self, j: int) -> Optional[BundledMethodTestCase]: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = BundledMethodTestCase() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # BundledMethodTestSuite + def TestCasesLength(self) -> int: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # BundledMethodTestSuite + def TestCasesIsNone(self) -> bool: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + +def BundledMethodTestSuiteStart(builder: flatbuffers.Builder): + builder.StartObject(2) + +def Start(builder: flatbuffers.Builder): + BundledMethodTestSuiteStart(builder) + +def BundledMethodTestSuiteAddMethodName(builder: flatbuffers.Builder, methodName: int): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(methodName), 0) + +def AddMethodName(builder: flatbuffers.Builder, methodName: int): + BundledMethodTestSuiteAddMethodName(builder, methodName) + +def BundledMethodTestSuiteAddTestCases(builder: flatbuffers.Builder, testCases: int): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(testCases), 0) + +def AddTestCases(builder: flatbuffers.Builder, testCases: int): + BundledMethodTestSuiteAddTestCases(builder, testCases) + +def BundledMethodTestSuiteStartTestCasesVector(builder, numElems: int) -> int: + return builder.StartVector(4, numElems, 4) + +def StartTestCasesVector(builder, numElems: int) -> int: + return BundledMethodTestSuiteStartTestCasesVector(builder, numElems) + +def BundledMethodTestSuiteEnd(builder: flatbuffers.Builder) -> int: + return builder.EndObject() + +def End(builder: flatbuffers.Builder) -> int: + return BundledMethodTestSuiteEnd(builder) + +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import BundledMethodTestCase +try: + from typing import List +except: + pass + +class BundledMethodTestSuiteT(object): + + # BundledMethodTestSuiteT + def __init__(self): + self.methodName = None # type: str + self.testCases = None # type: List[bundled_program_flatbuffer.BundledMethodTestCase.BundledMethodTestCaseT] + + @classmethod + def InitFromBuf(cls, buf, pos): + bundledMethodTestSuite = BundledMethodTestSuite() + bundledMethodTestSuite.Init(buf, pos) + return cls.InitFromObj(bundledMethodTestSuite) + + @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, bundledMethodTestSuite): + x = BundledMethodTestSuiteT() + x._UnPack(bundledMethodTestSuite) + return x + + # BundledMethodTestSuiteT + def _UnPack(self, bundledMethodTestSuite): + if bundledMethodTestSuite is None: + return + self.methodName = bundledMethodTestSuite.MethodName() + if not bundledMethodTestSuite.TestCasesIsNone(): + self.testCases = [] + for i in range(bundledMethodTestSuite.TestCasesLength()): + if bundledMethodTestSuite.TestCases(i) is None: + self.testCases.append(None) + else: + bundledMethodTestCase_ = bundled_program_flatbuffer.BundledMethodTestCase.BundledMethodTestCaseT.InitFromObj(bundledMethodTestSuite.TestCases(i)) + self.testCases.append(bundledMethodTestCase_) + + # BundledMethodTestSuiteT + def Pack(self, builder): + if self.methodName is not None: + methodName = builder.CreateString(self.methodName) + if self.testCases is not None: + testCaseslist = [] + for i in range(len(self.testCases)): + testCaseslist.append(self.testCases[i].Pack(builder)) + BundledMethodTestSuiteStartTestCasesVector(builder, len(self.testCases)) + for i in reversed(range(len(self.testCases))): + builder.PrependUOffsetTRelative(testCaseslist[i]) + testCases = builder.EndVector() + BundledMethodTestSuiteStart(builder) + if self.methodName is not None: + BundledMethodTestSuiteAddMethodName(builder, methodName) + if self.testCases is not None: + BundledMethodTestSuiteAddTestCases(builder, testCases) + bundledMethodTestSuite = BundledMethodTestSuiteEnd(builder) + return bundledMethodTestSuite diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledProgram.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledProgram.py new file mode 100644 index 00000000000..d6baed67f43 --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/BundledProgram.py @@ -0,0 +1,212 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +from executorch.devtools.bundled_program.serialize.generated import bundled_program_flatbuffer +import flatbuffers +from flatbuffers.compat import import_numpy +from typing import Any +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer.BundledMethodTestSuite import BundledMethodTestSuite +from typing import Optional +np = import_numpy() + +class BundledProgram(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset: int = 0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BundledProgram() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsBundledProgram(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def BundledProgramBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x42\x50\x30\x38", size_prefixed=size_prefixed) + + # BundledProgram + def Init(self, buf: bytes, pos: int): + self._tab = flatbuffers.table.Table(buf, pos) + + # BundledProgram + def Version(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # BundledProgram + def MethodTestSuites(self, j: int) -> Optional[BundledMethodTestSuite]: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + obj = BundledMethodTestSuite() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # BundledProgram + def MethodTestSuitesLength(self) -> int: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # BundledProgram + def MethodTestSuitesIsNone(self) -> bool: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # BundledProgram + def Program(self, j: int): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # BundledProgram + def ProgramAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # BundledProgram + def ProgramLength(self) -> int: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # BundledProgram + def ProgramIsNone(self) -> bool: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + +def BundledProgramStart(builder: flatbuffers.Builder): + builder.StartObject(3) + +def Start(builder: flatbuffers.Builder): + BundledProgramStart(builder) + +def BundledProgramAddVersion(builder: flatbuffers.Builder, version: int): + builder.PrependUint32Slot(0, version, 0) + +def AddVersion(builder: flatbuffers.Builder, version: int): + BundledProgramAddVersion(builder, version) + +def BundledProgramAddMethodTestSuites(builder: flatbuffers.Builder, methodTestSuites: int): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(methodTestSuites), 0) + +def AddMethodTestSuites(builder: flatbuffers.Builder, methodTestSuites: int): + BundledProgramAddMethodTestSuites(builder, methodTestSuites) + +def BundledProgramStartMethodTestSuitesVector(builder, numElems: int) -> int: + return builder.StartVector(4, numElems, 4) + +def StartMethodTestSuitesVector(builder, numElems: int) -> int: + return BundledProgramStartMethodTestSuitesVector(builder, numElems) + +def BundledProgramAddProgram(builder: flatbuffers.Builder, program: int): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(program), 0) + +def AddProgram(builder: flatbuffers.Builder, program: int): + BundledProgramAddProgram(builder, program) + +def BundledProgramStartProgramVector(builder, numElems: int) -> int: + return builder.StartVector(1, numElems, 1) + +def StartProgramVector(builder, numElems: int) -> int: + return BundledProgramStartProgramVector(builder, numElems) + +def BundledProgramEnd(builder: flatbuffers.Builder) -> int: + return builder.EndObject() + +def End(builder: flatbuffers.Builder) -> int: + return BundledProgramEnd(builder) + +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import BundledMethodTestSuite +try: + from typing import List +except: + pass + +class BundledProgramT(object): + + # BundledProgramT + def __init__(self): + self.version = 0 # type: int + self.methodTestSuites = None # type: List[bundled_program_flatbuffer.BundledMethodTestSuite.BundledMethodTestSuiteT] + self.program = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + bundledProgram = BundledProgram() + bundledProgram.Init(buf, pos) + return cls.InitFromObj(bundledProgram) + + @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, bundledProgram): + x = BundledProgramT() + x._UnPack(bundledProgram) + return x + + # BundledProgramT + def _UnPack(self, bundledProgram): + if bundledProgram is None: + return + self.version = bundledProgram.Version() + if not bundledProgram.MethodTestSuitesIsNone(): + self.methodTestSuites = [] + for i in range(bundledProgram.MethodTestSuitesLength()): + if bundledProgram.MethodTestSuites(i) is None: + self.methodTestSuites.append(None) + else: + bundledMethodTestSuite_ = bundled_program_flatbuffer.BundledMethodTestSuite.BundledMethodTestSuiteT.InitFromObj(bundledProgram.MethodTestSuites(i)) + self.methodTestSuites.append(bundledMethodTestSuite_) + if not bundledProgram.ProgramIsNone(): + if np is None: + self.program = [] + for i in range(bundledProgram.ProgramLength()): + self.program.append(bundledProgram.Program(i)) + else: + self.program = bundledProgram.ProgramAsNumpy() + + # BundledProgramT + def Pack(self, builder): + if self.methodTestSuites is not None: + methodTestSuiteslist = [] + for i in range(len(self.methodTestSuites)): + methodTestSuiteslist.append(self.methodTestSuites[i].Pack(builder)) + BundledProgramStartMethodTestSuitesVector(builder, len(self.methodTestSuites)) + for i in reversed(range(len(self.methodTestSuites))): + builder.PrependUOffsetTRelative(methodTestSuiteslist[i]) + methodTestSuites = builder.EndVector() + if self.program is not None: + if np is not None and type(self.program) is np.ndarray: + program = builder.CreateNumpyVector(self.program) + else: + BundledProgramStartProgramVector(builder, len(self.program)) + for i in reversed(range(len(self.program))): + builder.PrependUint8(self.program[i]) + program = builder.EndVector() + BundledProgramStart(builder) + BundledProgramAddVersion(builder, self.version) + if self.methodTestSuites is not None: + BundledProgramAddMethodTestSuites(builder, methodTestSuites) + if self.program is not None: + BundledProgramAddProgram(builder, program) + bundledProgram = BundledProgramEnd(builder) + return bundledProgram diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Double.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Double.py new file mode 100644 index 00000000000..ee849819a1f --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Double.py @@ -0,0 +1,92 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +import flatbuffers +from flatbuffers.compat import import_numpy +from typing import Any +np = import_numpy() + +class Double(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset: int = 0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Double() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsDouble(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def DoubleBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x42\x50\x30\x38", size_prefixed=size_prefixed) + + # Double + def Init(self, buf: bytes, pos: int): + self._tab = flatbuffers.table.Table(buf, pos) + + # Double + def DoubleVal(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos) + return 0.0 + +def DoubleStart(builder: flatbuffers.Builder): + builder.StartObject(1) + +def Start(builder: flatbuffers.Builder): + DoubleStart(builder) + +def DoubleAddDoubleVal(builder: flatbuffers.Builder, doubleVal: float): + builder.PrependFloat64Slot(0, doubleVal, 0.0) + +def AddDoubleVal(builder: flatbuffers.Builder, doubleVal: float): + DoubleAddDoubleVal(builder, doubleVal) + +def DoubleEnd(builder: flatbuffers.Builder) -> int: + return builder.EndObject() + +def End(builder: flatbuffers.Builder) -> int: + return DoubleEnd(builder) + + +class DoubleT(object): + + # DoubleT + def __init__(self): + self.doubleVal = 0.0 # type: float + + @classmethod + def InitFromBuf(cls, buf, pos): + double = Double() + double.Init(buf, pos) + return cls.InitFromObj(double) + + @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, double): + x = DoubleT() + x._UnPack(double) + return x + + # DoubleT + def _UnPack(self, double): + if double is None: + return + self.doubleVal = double.DoubleVal() + + # DoubleT + def Pack(self, builder): + DoubleStart(builder) + DoubleAddDoubleVal(builder, self.doubleVal) + double = DoubleEnd(builder) + return double diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Int.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Int.py new file mode 100644 index 00000000000..1442ffaafbf --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Int.py @@ -0,0 +1,92 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +import flatbuffers +from flatbuffers.compat import import_numpy +from typing import Any +np = import_numpy() + +class Int(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset: int = 0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Int() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsInt(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def IntBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x42\x50\x30\x38", size_prefixed=size_prefixed) + + # Int + def Init(self, buf: bytes, pos: int): + self._tab = flatbuffers.table.Table(buf, pos) + + # Int + def IntVal(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + +def IntStart(builder: flatbuffers.Builder): + builder.StartObject(1) + +def Start(builder: flatbuffers.Builder): + IntStart(builder) + +def IntAddIntVal(builder: flatbuffers.Builder, intVal: int): + builder.PrependInt64Slot(0, intVal, 0) + +def AddIntVal(builder: flatbuffers.Builder, intVal: int): + IntAddIntVal(builder, intVal) + +def IntEnd(builder: flatbuffers.Builder) -> int: + return builder.EndObject() + +def End(builder: flatbuffers.Builder) -> int: + return IntEnd(builder) + + +class IntT(object): + + # IntT + def __init__(self): + self.intVal = 0 # type: int + + @classmethod + def InitFromBuf(cls, buf, pos): + int = Int() + int.Init(buf, pos) + return cls.InitFromObj(int) + + @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, int): + x = IntT() + x._UnPack(int) + return x + + # IntT + def _UnPack(self, int): + if int is None: + return + self.intVal = int.IntVal() + + # IntT + def Pack(self, builder): + IntStart(builder) + IntAddIntVal(builder, self.intVal) + int = IntEnd(builder) + return int diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Tensor.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Tensor.py new file mode 100644 index 00000000000..d84ffcd7c48 --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Tensor.py @@ -0,0 +1,267 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +import flatbuffers +from flatbuffers.compat import import_numpy +from typing import Any +np = import_numpy() + +class Tensor(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset: int = 0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Tensor() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsTensor(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TensorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x42\x50\x30\x38", size_prefixed=size_prefixed) + + # Tensor + def Init(self, buf: bytes, pos: int): + self._tab = flatbuffers.table.Table(buf, pos) + + # Tensor + def ScalarType(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 + + # Tensor + def Sizes(self, j: int): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Tensor + def SizesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Tensor + def SizesLength(self) -> int: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Tensor + def SizesIsNone(self) -> bool: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # Tensor + def Data(self, j: int): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Tensor + def DataAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Tensor + def DataLength(self) -> int: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Tensor + def DataIsNone(self) -> bool: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # Tensor + def DimOrder(self, j: int): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Tensor + def DimOrderAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Tensor + def DimOrderLength(self) -> int: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Tensor + def DimOrderIsNone(self) -> bool: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + +def TensorStart(builder: flatbuffers.Builder): + builder.StartObject(4) + +def Start(builder: flatbuffers.Builder): + TensorStart(builder) + +def TensorAddScalarType(builder: flatbuffers.Builder, scalarType: int): + builder.PrependInt8Slot(0, scalarType, 0) + +def AddScalarType(builder: flatbuffers.Builder, scalarType: int): + TensorAddScalarType(builder, scalarType) + +def TensorAddSizes(builder: flatbuffers.Builder, sizes: int): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(sizes), 0) + +def AddSizes(builder: flatbuffers.Builder, sizes: int): + TensorAddSizes(builder, sizes) + +def TensorStartSizesVector(builder, numElems: int) -> int: + return builder.StartVector(4, numElems, 4) + +def StartSizesVector(builder, numElems: int) -> int: + return TensorStartSizesVector(builder, numElems) + +def TensorAddData(builder: flatbuffers.Builder, data: int): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) + +def AddData(builder: flatbuffers.Builder, data: int): + TensorAddData(builder, data) + +def TensorStartDataVector(builder, numElems: int) -> int: + return builder.StartVector(1, numElems, 1) + +def StartDataVector(builder, numElems: int) -> int: + return TensorStartDataVector(builder, numElems) + +def TensorAddDimOrder(builder: flatbuffers.Builder, dimOrder: int): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(dimOrder), 0) + +def AddDimOrder(builder: flatbuffers.Builder, dimOrder: int): + TensorAddDimOrder(builder, dimOrder) + +def TensorStartDimOrderVector(builder, numElems: int) -> int: + return builder.StartVector(1, numElems, 1) + +def StartDimOrderVector(builder, numElems: int) -> int: + return TensorStartDimOrderVector(builder, numElems) + +def TensorEnd(builder: flatbuffers.Builder) -> int: + return builder.EndObject() + +def End(builder: flatbuffers.Builder) -> int: + return TensorEnd(builder) + +try: + from typing import List +except: + pass + +class TensorT(object): + + # TensorT + def __init__(self): + self.scalarType = 0 # type: int + self.sizes = None # type: List[int] + self.data = None # type: List[int] + self.dimOrder = None # type: List[int] + + @classmethod + def InitFromBuf(cls, buf, pos): + tensor = Tensor() + tensor.Init(buf, pos) + return cls.InitFromObj(tensor) + + @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, tensor): + x = TensorT() + x._UnPack(tensor) + return x + + # TensorT + def _UnPack(self, tensor): + if tensor is None: + return + self.scalarType = tensor.ScalarType() + if not tensor.SizesIsNone(): + if np is None: + self.sizes = [] + for i in range(tensor.SizesLength()): + self.sizes.append(tensor.Sizes(i)) + else: + self.sizes = tensor.SizesAsNumpy() + if not tensor.DataIsNone(): + if np is None: + self.data = [] + for i in range(tensor.DataLength()): + self.data.append(tensor.Data(i)) + else: + self.data = tensor.DataAsNumpy() + if not tensor.DimOrderIsNone(): + if np is None: + self.dimOrder = [] + for i in range(tensor.DimOrderLength()): + self.dimOrder.append(tensor.DimOrder(i)) + else: + self.dimOrder = tensor.DimOrderAsNumpy() + + # TensorT + def Pack(self, builder): + if self.sizes is not None: + if np is not None and type(self.sizes) is np.ndarray: + sizes = builder.CreateNumpyVector(self.sizes) + else: + TensorStartSizesVector(builder, len(self.sizes)) + for i in reversed(range(len(self.sizes))): + builder.PrependInt32(self.sizes[i]) + sizes = builder.EndVector() + if self.data is not None: + if np is not None and type(self.data) is np.ndarray: + data = builder.CreateNumpyVector(self.data) + else: + TensorStartDataVector(builder, len(self.data)) + for i in reversed(range(len(self.data))): + builder.PrependUint8(self.data[i]) + data = builder.EndVector() + if self.dimOrder is not None: + if np is not None and type(self.dimOrder) is np.ndarray: + dimOrder = builder.CreateNumpyVector(self.dimOrder) + else: + TensorStartDimOrderVector(builder, len(self.dimOrder)) + for i in reversed(range(len(self.dimOrder))): + builder.PrependUint8(self.dimOrder[i]) + dimOrder = builder.EndVector() + TensorStart(builder) + TensorAddScalarType(builder, self.scalarType) + if self.sizes is not None: + TensorAddSizes(builder, sizes) + if self.data is not None: + TensorAddData(builder, data) + if self.dimOrder is not None: + TensorAddDimOrder(builder, dimOrder) + tensor = TensorEnd(builder) + return tensor diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Value.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Value.py new file mode 100644 index 00000000000..9bb518ec808 --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/Value.py @@ -0,0 +1,125 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +from executorch.devtools.bundled_program.serialize.generated import bundled_program_flatbuffer +import flatbuffers +from flatbuffers.compat import import_numpy +from typing import Any +from flatbuffers.table import Table +from typing import Optional +np = import_numpy() + +class Value(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset: int = 0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Value() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsValue(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ValueBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x42\x50\x30\x38", size_prefixed=size_prefixed) + + # Value + def Init(self, buf: bytes, pos: int): + self._tab = flatbuffers.table.Table(buf, pos) + + # Value + def ValType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # Value + def Val(self) -> Optional[flatbuffers.table.Table]: + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + +def ValueStart(builder: flatbuffers.Builder): + builder.StartObject(2) + +def Start(builder: flatbuffers.Builder): + ValueStart(builder) + +def ValueAddValType(builder: flatbuffers.Builder, valType: int): + builder.PrependUint8Slot(0, valType, 0) + +def AddValType(builder: flatbuffers.Builder, valType: int): + ValueAddValType(builder, valType) + +def ValueAddVal(builder: flatbuffers.Builder, val: int): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(val), 0) + +def AddVal(builder: flatbuffers.Builder, val: int): + ValueAddVal(builder, val) + +def ValueEnd(builder: flatbuffers.Builder) -> int: + return builder.EndObject() + +def End(builder: flatbuffers.Builder) -> int: + return ValueEnd(builder) + +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Bool +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Double +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Int +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Tensor +from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import ValueUnion +try: + from typing import Union +except: + pass + +class ValueT(object): + + # ValueT + def __init__(self): + self.valType = 0 # type: int + self.val = None # type: Union[None, bundled_program_flatbuffer.Tensor.TensorT, bundled_program_flatbuffer.Int.IntT, bundled_program_flatbuffer.Bool.BoolT, bundled_program_flatbuffer.Double.DoubleT] + + @classmethod + def InitFromBuf(cls, buf, pos): + value = Value() + value.Init(buf, pos) + return cls.InitFromObj(value) + + @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, value): + x = ValueT() + x._UnPack(value) + return x + + # ValueT + def _UnPack(self, value): + if value is None: + return + self.valType = value.ValType() + self.val = bundled_program_flatbuffer.ValueUnion.ValueUnionCreator(self.valType, value.Val()) + + # ValueT + def Pack(self, builder): + if self.val is not None: + val = self.val.Pack(builder) + ValueStart(builder) + ValueAddValType(builder, self.valType) + if self.val is not None: + ValueAddVal(builder, val) + value = ValueEnd(builder) + return value diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/ValueUnion.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/ValueUnion.py new file mode 100644 index 00000000000..1c391370325 --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/ValueUnion.py @@ -0,0 +1,29 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: bundled_program_flatbuffer + +from executorch.devtools.bundled_program.serialize.generated import bundled_program_flatbuffer +class ValueUnion(object): + NONE = 0 + Tensor = 1 + Int = 2 + Bool = 3 + Double = 4 + +def ValueUnionCreator(unionType, table): + from flatbuffers.table import Table + if not isinstance(table, Table): + return None + if unionType == ValueUnion().Tensor: + from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Tensor + return bundled_program_flatbuffer.Tensor.TensorT.InitFromBuf(table.Bytes, table.Pos) + if unionType == ValueUnion().Int: + from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Int + return bundled_program_flatbuffer.Int.IntT.InitFromBuf(table.Bytes, table.Pos) + if unionType == ValueUnion().Bool: + from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Bool + return bundled_program_flatbuffer.Bool.BoolT.InitFromBuf(table.Bytes, table.Pos) + if unionType == ValueUnion().Double: + from executorch.devtools.bundled_program.serialize.generated.bundled_program_flatbuffer import Double + return bundled_program_flatbuffer.Double.DoubleT.InitFromBuf(table.Bytes, table.Pos) + return None diff --git a/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/__init__.py b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/__init__.py new file mode 100644 index 00000000000..b1973a819c6 --- /dev/null +++ b/devtools/bundled_program/serialize/generated/bundled_program_flatbuffer/__init__.py @@ -0,0 +1,23 @@ +# automatically generated by devtools/bundled_program/serialize/generate_bundled_program.py, do not modify + +from . import Bool +from . import BundledMethodTestCase +from . import BundledMethodTestSuite +from . import BundledProgram +from . import Double +from . import Int +from . import Tensor +from . import Value +from . import ValueUnion + +__all__ = [ + "Bool", + "BundledMethodTestCase", + "BundledMethodTestSuite", + "BundledProgram", + "Double", + "Int", + "Tensor", + "Value", + "ValueUnion", +] diff --git a/devtools/bundled_program/serialize/generated/executorch_flatbuffer/ScalarType.py b/devtools/bundled_program/serialize/generated/executorch_flatbuffer/ScalarType.py new file mode 100644 index 00000000000..99b1fc5390c --- /dev/null +++ b/devtools/bundled_program/serialize/generated/executorch_flatbuffer/ScalarType.py @@ -0,0 +1,28 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: executorch_flatbuffer + +class ScalarType(object): + BYTE = 0 + CHAR = 1 + SHORT = 2 + INT = 3 + LONG = 4 + HALF = 5 + FLOAT = 6 + DOUBLE = 7 + BOOL = 11 + QINT8 = 12 + QUINT8 = 13 + QINT32 = 14 + BFLOAT16 = 15 + QUINT4X2 = 16 + QUINT2X4 = 17 + BITS16 = 22 + FLOAT8E5M2 = 23 + FLOAT8E4M3FN = 24 + FLOAT8E5M2FNUZ = 25 + FLOAT8E4M3FNUZ = 26 + UINT16 = 27 + UINT32 = 28 + UINT64 = 29 diff --git a/devtools/bundled_program/serialize/generated/executorch_flatbuffer/__init__.py b/devtools/bundled_program/serialize/generated/executorch_flatbuffer/__init__.py new file mode 100644 index 00000000000..59059a6867a --- /dev/null +++ b/devtools/bundled_program/serialize/generated/executorch_flatbuffer/__init__.py @@ -0,0 +1,7 @@ +# automatically generated by devtools/bundled_program/serialize/generate_bundled_program.py, do not modify + +from . import ScalarType + +__all__ = [ + "ScalarType", +]