algorand-python-testing 0.5.0__tar.gz → 0.6.0__tar.gz

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/.github/workflows/cd.yaml

@@ -65,8 +65,8 @@ jobs:
       - name: Check pre-commits (examples)
         run: hatch run examples:check
 
-      - name: Check wheels can be built
-        run: hatch build && hatch run cicd:clean_dist
+      - name: Build wheels
+        run: hatch build
 
       - name: Run tests (codebase)
         run: hatch run tests
@@ -74,17 +74,8 @@ jobs:
       - name: Run tests (examples)
         run: hatch run examples:tests
 
-      - name: Python Semantic Release
-        id: semantic-release
-        if: ${{ github.ref == 'refs/heads/main' }}
-        uses: python-semantic-release/python-semantic-release@master
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          prerelease: ${{ env.PRERELEASE == 'true' }}
-          root_options: $DRY_RUN
-
       - name: Publish to PyPI
-        if: ${{ !inputs.dry_run && steps.semantic-release.outputs.released == 'true' }}
+        if: ${{ !inputs.dry_run }}
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           packages-dir: dist

algorand_python_testing-0.6.0/.github/workflows/ci.yaml

@@ -0,0 +1,77 @@
+name: Check Python Code (algopy_testing)
+
+on:
+  workflow_call:
+  pull_request:
+  schedule:
+    - cron: "0 8 * * 1" # Each monday 8 AM UTC
+
+jobs:
+  check-python:
+    runs-on: "ubuntu-latest"
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v4
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+
+      - name: Install hatch
+        run: pip install hatch
+
+      - name: Start LocalNet
+        run: pipx install algokit && algokit localnet start
+
+      - name: Check pre-commits
+        run: hatch run check
+
+      - name: Check pre-commits (examples)
+        run: hatch run examples:check
+
+      - name: Validate examples folder
+        run: hatch run validate_examples
+
+      - name: Check wheels can be built
+        run: hatch build
+
+      - name: Check doctests
+        run: hatch run docs:test
+
+  test-python-matrix:
+    runs-on: "ubuntu-latest"
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "pip"
+
+      - name: Install hatch
+        run: pip install hatch
+
+      - name: Start LocalNet
+        run: pipx install algokit && algokit localnet start
+
+      - name: Run tests with Python ${{ matrix.python-version }}
+        run: hatch run test.py${{ matrix.python-version }}:ci
+
+      - name: Run examples tests with Python ${{ matrix.python-version }}
+        run: hatch run examples.py${{ matrix.python-version }}:tests
+
+      - name: Upload coverage artifacts
+        uses: actions/upload-artifact@v4
+        if: ${{ matrix.python-version == '3.13' }}
+        with:
+          name: coverage-reports
+          path: |
+            ./coverage.xml
+          retention-days: 14

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/CHANGELOG.md

@@ -1,4 +1,45 @@
 # CHANGELOG
+
+## v0.6.0 (2025-10-20)
+
+### Features
+
+* add mock implementations for validation functionality ([`ccde074`](https://github.com/algorandfoundation/algorand-python-testing/commit/ccde0740889bd68ef0fba418182d71ac0fc9f76a))
+
+### Documentation
+
+* add note about data validation in the testing library ([`bc47a68`](https://github.com/algorandfoundation/algorand-python-testing/commit/bc47a6838cf00907f2a718ddb8cb45fe97947d77))
+
+* add missing native types in coverage table ([`a95116c`](https://github.com/algorandfoundation/algorand-python-testing/commit/a95116c567dc77cfcf4f7ec517df60bb3d9d1eb5))
+
+## v0.6.0-beta.3 (2025-05-16)
+
+### Bug fixes
+
+* fixes type checking of tuples with primitive types ([`e971ad6`](https://github.com/algorandfoundation/algorand-python-testing/commit/e971ad6b125f269cd0874c09d58d8962f7622f8d))
+
+  Adds checks to ensure that type validation applies to classes only.
+
+## v0.6.0-beta.2 (2025-05-15)
+
+### Features
+
+* add stubs for box create function ([`1fe6fe5`](https://github.com/algorandfoundation/algorand-python-testing/commit/1fe6fe55358630a6abea2f69406821cb6031a4d5))
+
+## v0.6.0-beta.1 (2025-05-09)
+
+### Features
+
+* add stub implementation of algopy.size_of function for calculating static storage size of types ([`98e6816`](https://github.com/algorandfoundation/algorand-python-testing/commit/98e6816a48f1cff206f2c99d1384af1855d352c2))
+
+### Bug fixes
+
+* ensure size_of is exported from algopy module ([`01c055a`](https://github.com/algorandfoundation/algorand-python-testing/commit/01c055a4d2bd1fe17324bd91f7a83810900baa4e))
+
+### Documentation
+
+* include size_of in coverage doc ([`2c73646`](https://github.com/algorandfoundation/algorand-python-testing/commit/2c7364626357844437fd80b6039c112a87b277bb))
+
 ## v0.5.0 (2025-02-20)
 
 ## v0.5.0-beta.1 (2025-02-19)

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: algorand-python-testing
-Version: 0.5.0
+Version: 0.6.0
 Summary: Algorand Python testing library
 Project-URL: Documentation, https://github.com/algorandfoundation/puya/tree/main/algopy_testing#README.md
 Project-URL: Issues, https://github.com/algorandfoundation/puya/issues
@@ -12,9 +12,10 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.12
-Requires-Dist: algorand-python>=2.0
+Requires-Dist: algorand-python<3,>=2.0
 Requires-Dist: coincurve>=19.0.1
 Requires-Dist: ecdsa>=0.17.0
 Requires-Dist: pycryptodomex<4,>=3.6.0

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/docs/coverage.md

@@ -3,10 +3,11 @@
 See which `algorand-python` stubs are implemented by the `algorand-python-testing` library. See the [Concepts](testing-guide/concepts.md#types-of-algopy-stub-implementations) section for more details on the implementation categories. Refer to the [`algorand-python` stubs API](api.md) for the full list of the stubs for which the `algorand-python-testing` library provides implementations referenced in the table below.
 
 | Name                                        | Implementation type |
-| ------------------------------------------- | ------------------- |
+|---------------------------------------------|---------------------|
 | algopy.Account                              | Emulated            |
 | algopy.Application                          | Emulated            |
 | algopy.Asset                                | Emulated            |
+| algopy.Array                                | Native              |
 | algopy.BigUInt                              | Native              |
 | algopy.Box                                  | Emulated            |
 | algopy.BoxMap                               | Emulated            |
@@ -18,6 +19,7 @@ See which `algorand-python` stubs are implemented by the `algorand-python-testin
 | algopy.Contract                             | Emulated            |
 | algopy.Global                               | Emulated            |
 | algopy.GlobalState                          | Emulated            |
+| algopy.ImmutableArray                       | Native              |
 | algopy.LocalState                           | Emulated            |
 | algopy.LogicSig                             | Emulated            |
 | algopy.OnCompleteAction                     | Native              |
@@ -33,6 +35,7 @@ See which `algorand-python` stubs are implemented by the `algorand-python-testin
 | algopy.ensure_budget                        | Emulated            |
 | algopy.log                                  | Emulated            |
 | algopy.logicsig                             | Emulated            |
+| algopy.size_of                              | Emulated            |
 | algopy.subroutine                           | Native              |
 | algopy.uenumerate                           | Native              |
 | algopy.urange                               | Native              |

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/docs/testing-guide/concepts.md

@@ -56,3 +56,8 @@ As explained in the [introduction](index.md), `algorand-python-testing` _injects
 
 For a full list of all public `algopy` types and their corresponding implementation category, refer to the [Coverage](coverage.md) section.
 ```
+
+## Data Validation
+
+Algorand Python and the puya compiler have functionality to perform validation of transaction inputs via the `--validate-abi-args`, `--validate-abi-return` CLI arguments, `arc4.abimethod(validate_encoding=...)` decorator and `.validate()` methods. 
+The Algorand Python Testing library does *NOT* implement this validation behaviour, as you should test invalid inputs using an integrated test against a real Algorand network. 

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "algorand-python-testing"
-version = "0.5.0"
+version = "0.6.0"
 description = 'Algorand Python testing library'
 readme = "README.md"
 requires-python = ">=3.12"
@@ -18,6 +18,7 @@ classifiers = [
     "Topic :: Software Development :: Testing",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
     # ==========================================================================
@@ -29,7 +30,7 @@ dependencies = [
     "pynacl>=1.4.0,<2",
     "ecdsa>=0.17.0",
     "coincurve>=19.0.1",
-    "algorand-python>=2.0"
+    "algorand-python>=2.0,<3"
 ]
 
 [project.urls]
@@ -43,16 +44,13 @@ allow-direct-references = true
 [tool.hatch.build.targets.wheel]
 packages = ["src/algopy", 'src/algopy_testing', 'src/_algopy_testing']
 
-[[tool.hatch.envs.all.matrix]]
-python = ["3.12"]
-
 # default dev environment
 [tool.hatch.envs.default]
 type = "virtual"
 path = ".venv"
 python = "3.12"
 dependencies = [
-    "puyapy>=3.0",
+    "puyapy>=3.0,<5",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",
@@ -121,9 +119,29 @@ path = ".venv.cicd"
 dependencies = [
     "python-semantic-release>=9.8.5",
 ]
+
 [tool.hatch.envs.cicd.scripts]
 clean_dist = "rm -rf dist"
 
+# Testing environment with matrix
+[tool.hatch.envs.test]
+dependencies = [
+    "pytest>=7.4",
+    "pytest-mock>=3.10.0",
+    "pytest-xdist[psutil]>=3.3",
+    "pytest-cov>=4.1.0",
+    "py-algorand-sdk>=2.4.0",
+    "algokit-utils>=3.0.0",
+    "puyapy>=3.0,<5",
+]
+
+[tool.hatch.envs.test.scripts]
+run = "pytest --cov=src --cov-report=xml {args}"
+ci = "pytest --cov=src --cov-report=xml --cov-report=term"
+
+[[tool.hatch.envs.test.matrix]]
+python = ["3.12", "3.13"]
+
 # docs environment
 [tool.hatch.envs.docs]
 path = ".venv.docs"
@@ -159,14 +177,13 @@ dev = "hatch run docs:test  && sphinx-autobuild docs docs/_build"
 [tool.hatch.envs.examples]
 type = "virtual"
 path = ".venv.examples"
-python = "3.12"
 dev-mode = true
 skip-install = false
 post-install-commands = [
   "hatch run examples:reload_algopy_testing",
 ]
 dependencies = [
-    "algorand-python>=1.2",
+    "algorand-python>=1.2,<3",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",
@@ -188,6 +205,9 @@ check = [
     "hatch run mypy examples",
 ]
 
+[[tool.hatch.envs.examples.matrix]]
+python = ["3.12", "3.13"]
+
 # tool configurations
 [tool.black]
 line-length = 99

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/scripts/refresh_test_artifacts.py

@@ -31,6 +31,10 @@ def compile_contract(folder: Path) -> None:
         str(contract_path),
         "--out-dir",
         "data",
+        # testing library does not perform ABI validation
+        # so ensure compiled contracts also do not, so behaviour matches
+        "--no-validate-abi-args",
+        "--no-validate-abi-return",
     ]
     subprocess.run(
         compile_cmd,

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/scripts/validate_examples.py

@@ -70,9 +70,11 @@ def generate_client(folder: Path) -> None:
             text=True,
         )
     except subprocess.CalledProcessError as e:
-        if "No app specs" in e.stderr:
+        output = e.stdout + e.stderr
+        if "No app specs" in output:
             logger.warning(f"No app spec found for: {folder}, skipping...")
         else:
+            logger.exception(output)
             raise
 
 

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/src/_algopy_testing/arc4.py

@@ -172,6 +172,9 @@ class _ABIEncoded(BytesBacked):
 
         return algopy.Bytes(self._value)
 
+    def validate(self) -> None:
+        pass
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, _ABIEncoded):
             return self._type_info == other._type_info and self.bytes == other.bytes
@@ -742,7 +745,9 @@ class Address(StaticArray[Byte, typing.Literal[32]]):
 
 
 class _DynamicArrayTypeInfo(_TypeInfo):
-    def __init__(self, item_type: _TypeInfo):
+    _subclass_type: Callable[[], type] | None
+
+    def __init__(self, item_type: _TypeInfo) -> None:
         self.item_type = item_type
 
     @property
@@ -888,9 +893,20 @@ class DynamicArray(  # TODO: inherit from StaticArray?
         return f"{_arc4_type_repr(type(self))}({', '.join(items)})"
 
 
+class _DynamicBytesTypeInfo(_DynamicArrayTypeInfo):
+    def __init__(self) -> None:
+        super().__init__(Byte._type_info)
+
+    @property
+    def typ(self) -> type:
+        return DynamicBytes
+
+
 class DynamicBytes(DynamicArray[Byte]):
     """A variable sized array of bytes."""
 
+    _type_info: _DynamicBytesTypeInfo = _DynamicBytesTypeInfo()
+
     @typing.overload
     def __init__(self, *values: Byte | UInt8 | int): ...
 
@@ -996,6 +1012,12 @@ class Tuple(
                     )
         self._value = _encode(items)
 
+    def __bool__(self) -> bool:
+        try:
+            return bool(self.native)
+        except ValueError:
+            return False
+
     def __len__(self) -> int:
         return len(self.native)
 
@@ -1103,6 +1125,8 @@ class Struct(MutableBytes, _ABIEncoded, metaclass=_StructMeta):  # type: ignore[
     def from_bytes(cls, value: algopy.Bytes | bytes, /) -> typing.Self:
         tuple_type = _tuple_type_from_struct(cls)
         tuple_value = tuple_type.from_bytes(value)
+        if not tuple_value:
+            return typing.cast(typing.Self, tuple_value)
         return cls(*tuple_value.native)
 
     @property
@@ -1256,10 +1280,20 @@ def _compress_multiple_bool(value_list: list[Bool]) -> int:
     return result
 
 
+def get_max_bytes_static_len(type_info: _TypeInfo) -> int | None:
+    return _get_max_bytes_len_impl(type_info, static_size_only=True)
+
+
 def _get_max_bytes_len(type_info: _TypeInfo) -> int:
+    return _get_max_bytes_len_impl(type_info) or 0
+
+
+def _get_max_bytes_len_impl(type_info: _TypeInfo, *, static_size_only: bool = False) -> int | None:
     size = 0
     if isinstance(type_info, _DynamicArrayTypeInfo):
         size += _ABI_LENGTH_SIZE
+        if static_size_only:
+            return None
     elif isinstance(type_info, _TupleTypeInfo | _StructTypeInfo | _StaticArrayTypeInfo):
         i = 0
         if isinstance(type_info, _TupleTypeInfo | _StructTypeInfo):
@@ -1276,12 +1310,18 @@ def _get_max_bytes_len(type_info: _TypeInfo) -> int:
                 if bool_num % 8 != 0:
                     size += 1
             else:
-                child_byte_size = _get_max_bytes_len(child_types[i])
+                child_byte_size = _get_max_bytes_len_impl(
+                    child_types[i], static_size_only=static_size_only
+                )
+                if child_byte_size is None:
+                    return None
                 size += child_byte_size
             i += 1
     elif isinstance(type_info, _UIntTypeInfo):
         size = type_info.max_bytes_len
 
+    elif static_size_only:
+        return None
     return size
 
 

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/src/_algopy_testing/decorators/arc4.py

@@ -147,6 +147,7 @@ def abimethod(  # noqa: PLR0913
     allow_actions: Sequence[_AllowActions] = ("NoOp",),
     readonly: bool = False,
     default_args: Mapping[str, str | object] | None = None,
+    validate_encoding: typing.Literal["unsafe_disabled", "args"] = "args",  # noqa: ARG001
 ) -> Callable[[Callable[_P, _R]], Callable[_P, _R]] | Callable[_P, _R]:
     from _algopy_testing.utilities.log import log
 

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/src/_algopy_testing/models/account.py

@@ -128,6 +128,9 @@ class Account(BytesBacked):
     def public_key(self) -> str:
         return algosdk.encoding.encode_address(self._public_key)  # type: ignore[no-any-return]
 
+    def validate(self) -> None:
+        pass
+
     def __getattr__(self, name: str) -> typing.Any:
         try:
             return self.data.fields[name]  # type: ignore[literal-required]

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/src/_algopy_testing/models/contract.py

@@ -201,12 +201,12 @@ def _get_state_totals(contract: Contract, cls_state_totals: StateTotals) -> _Sta
 
     global_bytes = global_uints = local_bytes = local_uints = 0
     for type_ in get_global_states(contract).values():
-        if issubclass(type_, UInt64 | UInt64Backed | bool):
+        if isinstance(type_, type) and issubclass(type_, UInt64 | UInt64Backed | bool):
             global_uints += 1
         else:
             global_bytes += 1
     for type_ in get_local_states(contract).values():
-        if issubclass(type_, UInt64 | UInt64Backed | bool):
+        if isinstance(type_, type) and issubclass(type_, UInt64 | UInt64Backed | bool):
             local_uints += 1
         else:
             local_bytes += 1

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/src/_algopy_testing/op/pure.py

@@ -31,7 +31,7 @@ def bsqrt(a: BigUInt | int, /) -> BigUInt:
 def btoi(a: Bytes | bytes, /) -> UInt64:
     a_bytes = as_bytes(a)
     if len(a_bytes) > 8:
-        raise ValueError(f"btoi arg too long, got [{len(a_bytes)}]bytes")
+        raise ValueError(f"btoi arg too long, got {len(a_bytes)} bytes")
     return UInt64(int.from_bytes(a_bytes))
 
 

{algorand_python_testing-0.5.0 → algorand_python_testing-0.6.0}/src/_algopy_testing/primitives/array.py

@@ -102,6 +102,9 @@ class ImmutableArray(Serializable, typing.Generic[_T], metaclass=_ImmutableArray
     def from_bytes(cls, value: bytes, /) -> typing.Self:
         return deserialize_from_bytes(cls, value)
 
+    def validate(self) -> None:
+        pass
+
 
 class Array(Reversible[_T]):
 

algorand_python_testing-0.6.0/src/_algopy_testing/serialize.py

@@ -0,0 +1,151 @@
+import dataclasses
+import functools
+import inspect
+import typing
+from collections.abc import Callable, Sequence
+
+from _algopy_testing.primitives.uint64 import UInt64
+
+if typing.TYPE_CHECKING:
+    from _algopy_testing.arc4 import _ABIEncoded
+
+
+_T = typing.TypeVar("_T")
+_U = typing.TypeVar("_U")
+
+
+@dataclasses.dataclass(frozen=True)
+class _Serializer(typing.Generic[_T, _U]):
+    arc4_type: type[_U]
+    native_to_arc4: Callable[[_T], _U]
+    arc4_to_native: Callable[[_U], _T]
+
+
+def identity(i: _T) -> _T:
+    return i
+
+
+def get_native_to_arc4_serializer(typ: type) -> _Serializer[typing.Any, typing.Any]:
+    from _algopy_testing import arc4
+    from _algopy_testing.primitives import ImmutableArray
+    from _algopy_testing.protocols import UInt64Backed
+
+    origin_type = typing.get_origin(typ)
+    if origin_type is tuple:
+        return _get_tuple_serializer(typing.get_args(typ))
+    elif isinstance(typ, type):
+        if issubclass(typ, arc4._ABIEncoded):
+            return _Serializer(arc4_type=typ, native_to_arc4=identity, arc4_to_native=identity)
+        for native_type, simple_arc4_type in _simple_native_to_arc4_type_map().items():
+            if issubclass(typ, native_type):
+                return _Serializer(
+                    arc4_type=simple_arc4_type,
+                    native_to_arc4=simple_arc4_type,
+                    arc4_to_native=lambda n: n.native,
+                )
+        if issubclass(typ, UInt64Backed):
+            return _Serializer(
+                arc4_type=arc4.UInt64,
+                native_to_arc4=lambda n: arc4.UInt64(n.int_),
+                arc4_to_native=lambda a: typ.from_int(a.native),
+            )
+        if typing.NamedTuple in getattr(typ, "__orig_bases__", []):
+            tuple_fields = tuple(inspect.get_annotations(typ).values())
+            if any(isinstance(f, str) for f in tuple_fields):
+                raise TypeError("string annotations in typing.NamedTuple fields are not supported")
+            return _get_tuple_serializer(tuple_fields)
+        if issubclass(typ, ImmutableArray):
+            native_element_type = typ._element_type
+            element_serializer = get_native_to_arc4_serializer(native_element_type)
+            arc4_element_type = element_serializer.arc4_type
+            arc4_type = arc4.DynamicArray[arc4_element_type]  # type: ignore[valid-type]
+            return _Serializer(
+                arc4_type=arc4_type,
+                native_to_arc4=lambda arr: arc4_type(
+                    *(element_serializer.native_to_arc4(e) for e in arr)
+                ),
+                arc4_to_native=lambda arr: typ(
+                    *(element_serializer.arc4_to_native(e) for e in arr)
+                ),
+            )
+    raise TypeError(f"unserializable type: {typ}")
+
+
+@functools.cache
+def _simple_native_to_arc4_type_map() -> dict[type, type]:
+    from _algopy_testing import arc4
+    from _algopy_testing.models import Account
+    from _algopy_testing.primitives import BigUInt, Bytes, String
+
+    return {
+        bool: arc4.Bool,
+        UInt64: arc4.UInt64,
+        BigUInt: arc4.UInt512,
+        Account: arc4.Address,
+        Bytes: arc4.DynamicBytes,
+        String: arc4.String,
+    }
+
+
+def _get_tuple_serializer(item_types: tuple[type, ...]) -> _Serializer[typing.Any, typing.Any]:
+    from _algopy_testing import arc4
+
+    serializers = [get_native_to_arc4_serializer(i) for i in item_types]
+
+    def _items_to_arc4(items: Sequence[object]) -> tuple[object, ...]:
+        result = []
+        for item, serializer in zip(items, serializers, strict=True):
+            result.append(serializer.native_to_arc4(item))
+        return tuple(result)
+
+    def _items_to_native(items: Sequence[object]) -> tuple[object, ...]:
+        result = []
+        for item, serializer in zip(items, serializers, strict=True):
+            result.append(serializer.arc4_to_native(item))
+        return tuple(result)
+
+    return _Serializer(
+        arc4_type=arc4.Tuple[*(s.arc4_type for s in serializers)],  # type: ignore[misc]
+        native_to_arc4=lambda t: arc4.Tuple(_items_to_arc4(t)),
+        arc4_to_native=lambda t: _items_to_native(t),
+    )
+
+
+def serialize_to_bytes(value: object) -> bytes:
+    return native_to_arc4(value).bytes.value
+
+
+def type_of(value: object) -> type:
+    """Returns the type of value, this will also ensure the type is fully parametrized
+    if it is a generic type."""
+    # get fully parametrized tuples
+    if isinstance(value, tuple) and type(value) is tuple:
+        return tuple[*(type_of(i) for i in value)]  # type: ignore[misc, no-any-return]
+    else:
+        return type(value)
+
+
+def native_to_arc4(value: object) -> "_ABIEncoded":
+    from _algopy_testing import arc4
+
+    src_type = type_of(value)
+
+    serializer = get_native_to_arc4_serializer(src_type)
+    arc4_value = serializer.native_to_arc4(value)
+    assert isinstance(arc4_value, arc4._ABIEncoded)
+    return arc4_value
+
+
+def compare_type(value_type: type, typ: type) -> bool:
+    if typing.NamedTuple in getattr(typ, "__orig_bases__", []):
+        tuple_fields: Sequence[type] = list(inspect.get_annotations(typ).values())
+        typ = tuple[*tuple_fields]  # type: ignore[valid-type]
+    return value_type == typ
+
+
+def deserialize_from_bytes(typ: type[_T], bites: bytes) -> _T:
+    serializer = get_native_to_arc4_serializer(typ)
+    arc4_value = serializer.arc4_type.from_bytes(bites)
+    native_value = serializer.arc4_to_native(arc4_value)
+    assert compare_type(type_of(native_value), typ) or isinstance(native_value, typ)
+    return native_value  # type: ignore[no-any-return]