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 777e9f021f9..d50d597d968 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", +]