algorand-python-testing 0.6.0b1__tar.gz → 0.6.0b3__tar.gz

algorand_python_testing-0.6.0b3/.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.6.0b1 → algorand_python_testing-0.6.0b3}/CHANGELOG.md

@@ -1,4 +1,18 @@
 # CHANGELOG
+## 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

{algorand_python_testing-0.6.0b1 → algorand_python_testing-0.6.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: algorand-python-testing
-Version: 0.6.0b1
+Version: 0.6.0b3
 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,6 +12,7 @@ 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

{algorand_python_testing-0.6.0b1 → algorand_python_testing-0.6.0b3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "algorand-python-testing"
-version = "0.6.0-beta.1"
+version = "0.6.0-beta.3"
 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 = [
     # ==========================================================================
@@ -43,9 +44,6 @@ 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"
@@ -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",
+]
+
+[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,7 +177,6 @@ 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 = [
@@ -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.6.0b3/src/_algopy_testing/serialize.py

@@ -0,0 +1,144 @@
+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 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 isinstance(native_value, typ)
+    return native_value

{algorand_python_testing-0.6.0b1 → algorand_python_testing-0.6.0b3}/src/_algopy_testing/state/box.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 import typing
+import warnings
 
 import _algopy_testing
 from _algopy_testing.constants import MAX_BOX_SIZE
 from _algopy_testing.context_helpers import lazy_context
 from _algopy_testing.mutable import set_attr_on_mutate, set_item_on_mutate
 from _algopy_testing.state.utils import cast_from_bytes, cast_to_bytes
-from _algopy_testing.utils import as_bytes, as_string
+from _algopy_testing.utils import as_bytes, as_int64, as_string, get_static_size_of
 
 _TKey = typing.TypeVar("_TKey")
 _TValue = typing.TypeVar("_TValue")
@@ -38,6 +39,45 @@ class Box(typing.Generic[_TValue]):
     def __bool__(self) -> bool:
         return lazy_context.ledger.box_exists(self.app_id, self.key)
 
+    def create(self, *, size: algopy.UInt64 | int | None = None) -> bool:
+        missing_size_err_msg = (
+            f"{self._type} does not have a fixed byte size. Please specify a size argument"
+        )
+
+        size_arg = None if size is None else as_int64(size)
+        content_type_size = get_static_size_of(self._type)
+
+        if content_type_size is None and size_arg is None:
+            raise ValueError(missing_size_err_msg)
+        if content_type_size is not None and size_arg is not None:
+            if size_arg < content_type_size:
+                warnings.warn(
+                    f"Box size should not be less than {content_type_size}",
+                    stacklevel=2,
+                )
+
+            if size_arg > content_type_size:
+                warnings.warn(
+                    f"Size is set to {size_arg} but {self._type} has a fixed size of {content_type_size}",  # noqa: E501
+                    stacklevel=2,
+                )
+
+        size_int = size_arg if size_arg is not None else content_type_size
+        assert size_int is not None, missing_size_err_msg
+
+        if size_int > MAX_BOX_SIZE:
+            raise ValueError(f"Box size cannot exceed {MAX_BOX_SIZE}")
+
+        box_exists = lazy_context.ledger.box_exists(self.app_id, self.key)
+        if box_exists:
+            if self.length == size_int:
+                return False
+            else:
+                raise ValueError(f"Box already exists with a different size: {self.length}")
+
+        lazy_context.ledger.set_box(self.app_id, self.key, b"\x00" * size_int)
+        return True
+
     @property
     def key(self) -> algopy.Bytes:
         if not self._key:

algorand_python_testing-0.6.0b3/src/_algopy_testing/utilities/size_of.py

@@ -0,0 +1,9 @@
+from _algopy_testing.primitives.uint64 import UInt64
+from _algopy_testing.utils import get_static_size_of
+
+
+def size_of(typ: type | object, /) -> UInt64:
+    size = get_static_size_of(typ)
+    if size is None:
+        raise ValueError(f"{typ} is dynamically sized")
+    return UInt64(size)

{algorand_python_testing-0.6.0b1 → algorand_python_testing-0.6.0b3}/src/_algopy_testing/utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import secrets
+import types
 import typing
 from typing import TYPE_CHECKING
 
@@ -22,8 +23,6 @@ from _algopy_testing.constants import (
 )
 
 if TYPE_CHECKING:
-    import types
-
     import algopy
 
     from _algopy_testing.op.global_values import GlobalFields
@@ -195,3 +194,22 @@ def raise_mocked_function_error(func_name: str) -> typing.Never:
         f"{func_name!r} is not available in test context. "
         "Mock using your preferred testing framework."
     )
+
+
+def get_static_size_of(typ: type | object, /) -> int | None:
+    from _algopy_testing import UInt64
+    from _algopy_testing.arc4 import get_max_bytes_static_len
+    from _algopy_testing.serialize import get_native_to_arc4_serializer
+
+    if isinstance(typ, types.GenericAlias):
+        pass
+    elif not isinstance(typ, type):
+        typ = type(typ)
+
+    if typ is bool:  # treat bool on its own as a uint64
+        typ = UInt64
+    serializer = get_native_to_arc4_serializer(typ)  # type: ignore[arg-type]
+    type_info = serializer.arc4_type._type_info
+    size = get_max_bytes_static_len(type_info)
+
+    return size

{algorand_python_testing-0.6.0b1 → algorand_python_testing-0.6.0b3}/tests/arc4/test_tuple.py

@@ -2,8 +2,10 @@ import typing
 
 import pytest
 from _algopy_testing import arc4
+from algopy_testing import AlgopyTestContext, algopy_testing_context
 from algosdk import abi
 
+from tests.artifacts.Tuples.contract import TuplesContract
 from tests.util import int_to_bytes
 
 _abi_string = "hello"
@@ -15,6 +17,14 @@ _arc4_string = arc4.String("hello")
 _arc4_uint8 = arc4.UInt8(42)
 _arc4_bool = arc4.Bool(True)
 
+
+# New fixture
+@pytest.fixture()
+def context() -> typing.Generator[AlgopyTestContext, None, None]:
+    with algopy_testing_context() as ctx:
+        yield ctx
+
+
 _test_data = [
     (
         abi.ABIType.from_string("(uint8,bool,bool)"),
@@ -279,3 +289,8 @@ def _compare_abi_and_arc4_values(
         assert arc4_value.native == abi_value
     else:
         assert arc4_value.bytes == int_to_bytes(abi_value, len(arc4_value.bytes))
+
+
+def test_tuple_return_with_primitive_type(context: AlgopyTestContext) -> None:  # noqa: ARG001
+    contract = TuplesContract()
+    contract.test_tuple_with_primitive_type()

algorand_python_testing-0.6.0b3/tests/artifacts/Tuples/contract.py

@@ -0,0 +1,11 @@
+from algopy import (
+    ARC4Contract,
+    UInt64,
+    arc4,
+)
+
+
+class TuplesContract(ARC4Contract, avm_version=11):
+    @arc4.abimethod()
+    def test_tuple_with_primitive_type(self) -> tuple[UInt64, bool]:
+        return (UInt64(0), True)

algorand_python_testing-0.6.0b3/tests/artifacts/Tuples/data/TuplesContract.approval.teal

@@ -0,0 +1,42 @@
+#pragma version 11
+#pragma typetrack false
+
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    // tests/artifacts/Tuples/contract.py:8
+    // class TuplesContract(ARC4Contract, avm_version=11):
+    txn NumAppArgs
+    bz main_bare_routing@6
+    pushbytes 0x7229d79a // method "test_tuple_with_primitive_type()(uint64,bool)"
+    txna ApplicationArgs 0
+    match main_test_tuple_with_primitive_type_route@3
+
+main_after_if_else@10:
+    // tests/artifacts/Tuples/contract.py:8
+    // class TuplesContract(ARC4Contract, avm_version=11):
+    pushint 0 // 0
+    return
+
+main_test_tuple_with_primitive_type_route@3:
+    // tests/artifacts/Tuples/contract.py:9
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    pushbytes 0x151f7c75000000000000000080
+    log
+    pushint 1 // 1
+    return
+
+main_bare_routing@6:
+    // tests/artifacts/Tuples/contract.py:8
+    // class TuplesContract(ARC4Contract, avm_version=11):
+    txn OnCompletion
+    bnz main_after_if_else@10
+    txn ApplicationID
+    !
+    assert // can only call when creating
+    pushint 1 // 1
+    return

algorand_python_testing-0.6.0b3/tests/artifacts/Tuples/data/TuplesContract.arc32.json

@@ -0,0 +1,50 @@
+{
+    "hints": {
+        "test_tuple_with_primitive_type()(uint64,bool)": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        }
+    },
+    "source": {
+        "approval": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9UdXBsZXMvY29udHJhY3QucHk6OAogICAgLy8gY2xhc3MgVHVwbGVzQ29udHJhY3QoQVJDNENvbnRyYWN0LCBhdm1fdmVyc2lvbj0xMSk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9iYXJlX3JvdXRpbmdANgogICAgcHVzaGJ5dGVzIDB4NzIyOWQ3OWEgLy8gbWV0aG9kICJ0ZXN0X3R1cGxlX3dpdGhfcHJpbWl0aXZlX3R5cGUoKSh1aW50NjQsYm9vbCkiCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCBtYWluX3Rlc3RfdHVwbGVfd2l0aF9wcmltaXRpdmVfdHlwZV9yb3V0ZUAzCgptYWluX2FmdGVyX2lmX2Vsc2VAMTA6CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvVHVwbGVzL2NvbnRyYWN0LnB5OjgKICAgIC8vIGNsYXNzIFR1cGxlc0NvbnRyYWN0KEFSQzRDb250cmFjdCwgYXZtX3ZlcnNpb249MTEpOgogICAgcHVzaGludCAwIC8vIDAKICAgIHJldHVybgoKbWFpbl90ZXN0X3R1cGxlX3dpdGhfcHJpbWl0aXZlX3R5cGVfcm91dGVAMzoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9UdXBsZXMvY29udHJhY3QucHk6OQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIGFzc2VydCAvLyBPbkNvbXBsZXRpb24gaXMgbm90IE5vT3AKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICBhc3NlcnQgLy8gY2FuIG9ubHkgY2FsbCB3aGVuIG5vdCBjcmVhdGluZwogICAgcHVzaGJ5dGVzIDB4MTUxZjdjNzUwMDAwMDAwMDAwMDAwMDAwODAKICAgIGxvZwogICAgcHVzaGludCAxIC8vIDEKICAgIHJldHVybgoKbWFpbl9iYXJlX3JvdXRpbmdANjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9UdXBsZXMvY29udHJhY3QucHk6OAogICAgLy8gY2xhc3MgVHVwbGVzQ29udHJhY3QoQVJDNENvbnRyYWN0LCBhdm1fdmVyc2lvbj0xMSk6CiAgICB0eG4gT25Db21wbGV0aW9uCiAgICBibnogbWFpbl9hZnRlcl9pZl9lbHNlQDEwCiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgIQogICAgYXNzZXJ0IC8vIGNhbiBvbmx5IGNhbGwgd2hlbiBjcmVhdGluZwogICAgcHVzaGludCAxIC8vIDEKICAgIHJldHVybgo=",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
+    },
+    "state": {
+        "global": {
+            "num_byte_slices": 0,
+            "num_uints": 0
+        },
+        "local": {
+            "num_byte_slices": 0,
+            "num_uints": 0
+        }
+    },
+    "schema": {
+        "global": {
+            "declared": {},
+            "reserved": {}
+        },
+        "local": {
+            "declared": {},
+            "reserved": {}
+        }
+    },
+    "contract": {
+        "name": "TuplesContract",
+        "methods": [
+            {
+                "name": "test_tuple_with_primitive_type",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,bool)"
+                }
+            }
+        ],
+        "networks": {}
+    },
+    "bare_call_config": {
+        "no_op": "CREATE"
+    }
+}

algorand_python_testing-0.6.0b3/tests/artifacts/Tuples/data/TuplesContract.arc56.json

@@ -0,0 +1,102 @@
+{
+    "name": "TuplesContract",
+    "structs": {},
+    "methods": [
+        {
+            "name": "test_tuple_with_primitive_type",
+            "args": [],
+            "returns": {
+                "type": "(uint64,bool)"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
+        }
+    ],
+    "arcs": [
+        22,
+        28
+    ],
+    "networks": {},
+    "state": {
+        "schema": {
+            "global": {
+                "ints": 0,
+                "bytes": 0
+            },
+            "local": {
+                "ints": 0,
+                "bytes": 0
+            }
+        },
+        "keys": {
+            "global": {},
+            "local": {},
+            "box": {}
+        },
+        "maps": {
+            "global": {},
+            "local": {},
+            "box": {}
+        }
+    },
+    "bareActions": {
+        "create": [
+            "NoOp"
+        ],
+        "call": []
+    },
+    "sourceInfo": {
+        "approval": {
+            "sourceInfo": [
+                {
+                    "pc": [
+                        25
+                    ],
+                    "errorMessage": "OnCompletion is not NoOp"
+                },
+                {
+                    "pc": [
+                        56
+                    ],
+                    "errorMessage": "can only call when creating"
+                },
+                {
+                    "pc": [
+                        28
+                    ],
+                    "errorMessage": "can only call when not creating"
+                }
+            ],
+            "pcOffsetMethod": "none"
+        },
+        "clear": {
+            "sourceInfo": [],
+            "pcOffsetMethod": "none"
+        }
+    },
+    "source": {
+        "approval": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9UdXBsZXMvY29udHJhY3QucHk6OAogICAgLy8gY2xhc3MgVHVwbGVzQ29udHJhY3QoQVJDNENvbnRyYWN0LCBhdm1fdmVyc2lvbj0xMSk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9iYXJlX3JvdXRpbmdANgogICAgcHVzaGJ5dGVzIDB4NzIyOWQ3OWEgLy8gbWV0aG9kICJ0ZXN0X3R1cGxlX3dpdGhfcHJpbWl0aXZlX3R5cGUoKSh1aW50NjQsYm9vbCkiCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCBtYWluX3Rlc3RfdHVwbGVfd2l0aF9wcmltaXRpdmVfdHlwZV9yb3V0ZUAzCgptYWluX2FmdGVyX2lmX2Vsc2VAMTA6CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvVHVwbGVzL2NvbnRyYWN0LnB5OjgKICAgIC8vIGNsYXNzIFR1cGxlc0NvbnRyYWN0KEFSQzRDb250cmFjdCwgYXZtX3ZlcnNpb249MTEpOgogICAgcHVzaGludCAwIC8vIDAKICAgIHJldHVybgoKbWFpbl90ZXN0X3R1cGxlX3dpdGhfcHJpbWl0aXZlX3R5cGVfcm91dGVAMzoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9UdXBsZXMvY29udHJhY3QucHk6OQogICAgLy8gQGFyYzQuYWJpbWV0aG9kKCkKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIGFzc2VydCAvLyBPbkNvbXBsZXRpb24gaXMgbm90IE5vT3AKICAgIHR4biBBcHBsaWNhdGlvbklECiAgICBhc3NlcnQgLy8gY2FuIG9ubHkgY2FsbCB3aGVuIG5vdCBjcmVhdGluZwogICAgcHVzaGJ5dGVzIDB4MTUxZjdjNzUwMDAwMDAwMDAwMDAwMDAwODAKICAgIGxvZwogICAgcHVzaGludCAxIC8vIDEKICAgIHJldHVybgoKbWFpbl9iYXJlX3JvdXRpbmdANjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9UdXBsZXMvY29udHJhY3QucHk6OAogICAgLy8gY2xhc3MgVHVwbGVzQ29udHJhY3QoQVJDNENvbnRyYWN0LCBhdm1fdmVyc2lvbj0xMSk6CiAgICB0eG4gT25Db21wbGV0aW9uCiAgICBibnogbWFpbl9hZnRlcl9pZl9lbHNlQDEwCiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgIQogICAgYXNzZXJ0IC8vIGNhbiBvbmx5IGNhbGwgd2hlbiBjcmVhdGluZwogICAgcHVzaGludCAxIC8vIDEKICAgIHJldHVybgo=",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
+    },
+    "byteCode": {
+        "approval": "CzEbQQAqgARyKdeaNhoAjgEAA4EAQzEZFEQxGESADRUffHUAAAAAAAAAAICwgQFDMRlA/94xGBREgQFD",
+        "clear": "C4EBQw=="
+    },
+    "compilerInfo": {
+        "compiler": "puya",
+        "compilerVersion": {
+            "major": 4,
+            "minor": 8,
+            "patch": 1
+        }
+    },
+    "events": [],
+    "templateVariables": {}
+}