algorand-python-testing 1.2.0b8__tar.gz → 1.2.0b10__tar.gz

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/CHANGELOG.md

@@ -1,4 +1,22 @@
 # CHANGELOG
+## v1.2.0-beta.10 (2026-04-14)
+
+### Features
+
+* support native-typed fields in arc4.Struct ([`6ec0127`](https://github.com/algorandfoundation/algorand-python-testing/commit/6ec0127d096f4c2972a6ce844d8a196c384828f6))
+
+  This unblocks `arc4.encode`/`arc4.decode` of structs with mixed field annotations and lets the AVM parity test invoke the contract directly in-process alongside the AVM check, exercising `test_native_struct` on both paths instead of AVM only.
+
+* add support for arc4.encode and arc4.decode functions ([`032b2a8`](https://github.com/algorandfoundation/algorand-python-testing/commit/032b2a826338bc3ff92bca774f3361b39e3afc6e))
+
+  also migrate `UInt64Backed` serializer off the deprecated `.native` accessor
+
+## v1.2.0-beta.9 (2026-04-10)
+
+### Features
+
+* add arguments to logicsig ([`74ac11e`](https://github.com/algorandfoundation/algorand-python-testing/commit/74ac11e74af79cf50c9b64de74221ef8f8d5bae4))
+
 ## v1.2.0-beta.8 (2026-04-09)
 
 ## v1.2.0-beta.7 (2026-04-09)

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: algorand-python-testing
-Version: 1.2.0b8
+Version: 1.2.0b10
 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

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/docs/coverage.md

@@ -74,7 +74,9 @@ See which `algorand-python` stubs are implemented by the `algorand-python-testin
 | algopy.arc4.abimethod                       | Emulated            |
 | algopy.arc4.arc4_signature                  | Native              |
 | algopy.arc4.baremethod                      | Emulated            |
+| algopy.arc4.decode                          | Emulated            |
 | algopy.arc4.emit                            | Emulated            |
+| algopy.arc4.encode                          | Emulated            |
 | algopy.arc4.abi_call                        | Mockable            |
 | algopy.arc4.arc4_create                     | Mockable            |
 | algopy.arc4.arc4_update                     | Mockable            |

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/docs/testing-guide/concepts.md

@@ -61,5 +61,5 @@ For a full list of all public `algopy` types and their corresponding implementat
 
 ## 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 (or its alias, `algopy.public`) and `.validate()` methods.
+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 (or its alias, `algopy.public`), `.validate()` methods, and the `validate` parameter of `arc4.decode(...)`.
 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-1.2.0b8 → algorand_python_testing-1.2.0b10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "algorand-python-testing"
-version = "1.2.0-beta.8"
+version = "1.2.0-beta.10"
 description = 'Algorand Python testing library'
 readme = "README.md"
 requires-python = ">=3.12"

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/src/_algopy_testing/arc4.py

@@ -26,7 +26,7 @@ from _algopy_testing.mutable import (
 )
 from _algopy_testing.primitives import Bytes
 from _algopy_testing.protocols import BytesBacked
-from _algopy_testing.serialize import get_native_to_arc4_serializer
+from _algopy_testing.serialize import get_native_to_arc4_serializer, native_to_arc4
 from _algopy_testing.utils import (
     as_bytes,
     as_int,
@@ -73,7 +73,9 @@ __all__ = [
     "arc4_create",
     "arc4_signature",
     "arc4_update",
+    "decode",
     "emit",
+    "encode",
 ]
 
 _ABI_LENGTH_SIZE = 2
@@ -1152,9 +1154,40 @@ class _StructMeta(type):
     pass
 
 
+def _is_arc4_type(field_type: typing.Any) -> bool:
+    return isinstance(field_type, type) and issubclass(field_type, _ABIEncoded)
+
+
+def _arc4_type_for_field(field_type: typing.Any) -> type[_ABIEncoded]:
+    """Resolve a struct field's declared type to its ARC-4 equivalent.
+
+    Fields annotated with ARC-4 types are returned as-is; native/algopy types
+    are mapped via the serializer registry so `arc4.Struct` accepts either.
+    """
+    if _is_arc4_type(field_type):
+        return field_type  # type: ignore[no-any-return]
+    return get_native_to_arc4_serializer(field_type).arc4_type
+
+
+def _encode_to_arc4(value: object) -> _ABIEncoded:
+    """Wrap a struct field value for encoding — ARC-4 instances pass through, native
+    values are converted via the serializer registry."""
+    if isinstance(value, _ABIEncoded):
+        return value
+    return native_to_arc4(value)
+
+
+def _to_native_type(field_type: typing.Any, arc4_value: _ABIEncoded) -> object:
+    """Convert a decoded ARC-4 value back to the declared field type — ARC-4 annotations
+    pass through, native annotations go through `arc4_to_native`."""
+    if _is_arc4_type(field_type):
+        return arc4_value
+    return get_native_to_arc4_serializer(field_type).arc4_to_native(arc4_value)
+
+
 def _tuple_type_from_struct(struct: type[Struct]) -> type[Tuple]:  # type: ignore[type-arg]
-    field_types = [f.type for f in struct._type_info.fields]
-    return parameterize_type(Tuple, *field_types)  # type: ignore[arg-type]
+    field_types = [_arc4_type_for_field(f.type) for f in struct._type_info.fields]
+    return parameterize_type(Tuple, *field_types)
 
 
 class Struct(MutableBytes, _ABIEncoded, metaclass=_StructMeta):
@@ -1198,7 +1231,13 @@ class Struct(MutableBytes, _ABIEncoded, metaclass=_StructMeta):
         tuple_value = tuple_type.from_bytes(value)
         if not tuple_value:
             return typing.cast("typing.Self", tuple_value)
-        return cls(*tuple_value.native)
+        # convert each decoded ARC-4 item to the declared field type (ARC-4
+        # annotations pass through, native annotations go through arc4_to_native)
+        items = [
+            _to_native_type(field.type, arc4_item)
+            for arc4_item, field in zip(tuple_value.native, cls._type_info.fields, strict=True)
+        ]
+        return cls(*items)
 
     @property
     def bytes(self) -> algopy.Bytes:
@@ -1208,8 +1247,10 @@ class Struct(MutableBytes, _ABIEncoded, metaclass=_StructMeta):
     @property
     def _as_tuple(self) -> Tuple:  # type: ignore[type-arg]
         # can't use dataclass.astuple here as that processes all dataclasses
-        # in the object graph, not just immediate fields
-        tuple_items = tuple(getattr(self, field.name) for field in dataclasses.fields(self))
+        # in the object graph, not just immediate fields.
+        tuple_items = tuple(
+            _encode_to_arc4(getattr(self, field.name)) for field in dataclasses.fields(self)
+        )
         return Tuple(tuple_items)
 
     def _replace(self, **kwargs: typing.Any) -> typing.Self:
@@ -1270,9 +1311,36 @@ def emit(event: str | Struct, /, *args: object) -> None:
     log(event_hash[:4] + event_data.value)
 
 
-def _cast_arg_as_arc4(arg: object) -> _ABIEncoded:
-    from _algopy_testing.serialize import native_to_arc4
+def encode(value: object, /) -> algopy.Bytes:
+    return _encode_to_arc4(value).bytes
+
+
+_TDecode = typing.TypeVar("_TDecode")
+
 
+def decode(
+    typ: type[_TDecode],
+    value: algopy.Bytes | bytes,
+    /,
+    *,
+    validate: typing.Literal[True, False] = True,
+) -> _TDecode:
+    raw = value.value if isinstance(value, Bytes) else value
+
+    if isinstance(typ, type) and issubclass(typ, _ABIEncoded):
+        arc4_value = typ.from_bytes(raw)
+        if validate:
+            arc4_value.validate()
+        return arc4_value
+
+    serializer = get_native_to_arc4_serializer(typ)
+    arc4_value = serializer.arc4_type.from_bytes(raw)
+    if validate:
+        arc4_value.validate()
+    return serializer.arc4_to_native(arc4_value)  # type: ignore[no-any-return]
+
+
+def _cast_arg_as_arc4(arg: object) -> _ABIEncoded:
     if isinstance(arg, int) and not isinstance(arg, bool):
         return UInt64(arg) if arg <= MAX_UINT64 else UInt512(arg)
     if isinstance(arg, bytes):

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/src/_algopy_testing/context.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
+import inspect
 import typing
 
 from _algopy_testing.context_helpers import LedgerContext, TransactionContext
+from _algopy_testing.state.utils import cast_to_bytes
 from _algopy_testing.utils import generate_random_account
 from _algopy_testing.value_generators import AlgopyValueGenerator
 
 if typing.TYPE_CHECKING:
-    from collections.abc import Sequence
-
     import algopy
 
 
@@ -35,7 +35,7 @@ class AlgopyTestContext:
         self._default_sender = algopy.Account(default_sender or generate_random_account().addr)
         self._template_vars: dict[str, typing.Any] = template_vars or {}
 
-        self._active_lsig_args: Sequence[algopy.Bytes] = ()
+        self._active_lsig_args = list[bytes]()
         self._ledger_context = LedgerContext()
         self._txn_context = TransactionContext()
         self._value_generator = AlgopyValueGenerator()
@@ -84,14 +84,23 @@ class AlgopyTestContext:
         """
         self._template_vars[name] = value
 
-    def execute_logicsig(self, lsig: algopy.LogicSig, *args: algopy.Bytes) -> bool | algopy.UInt64:
-        """Execute a logic signature using provided args."""
+    def execute_logicsig(
+        self, lsig: algopy.LogicSig, /, *args: typing.Any
+    ) -> bool | algopy.UInt64:
+        """Execute a logic signature.
 
-        self._active_lsig_args = args
+        If the logicsig's wrapped function accepts parameters, args are passed directly.
+        args are also available via algopy.op.arg().
+        """
+        sig = inspect.signature(lsig.func)
+        self._active_lsig_args = [cast_to_bytes(a) for a in args]
         try:
-            return lsig.func()
+            if sig.parameters:
+                return lsig.func(*args)
+            else:
+                return lsig.func()
         finally:
-            self._active_lsig_args = ()
+            self._active_lsig_args = []
 
     def clear_transaction_context(self) -> None:
         """Clear the transaction context."""

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/src/_algopy_testing/models/logicsig.py

@@ -9,25 +9,33 @@ if typing.TYPE_CHECKING:
     import algopy
 
 
+_P = typing.ParamSpec("_P")
+
+
 class LogicSig:
     """A logic signature."""
 
-    def __init__(self, func: Callable[[], bool | algopy.UInt64], name: str):
+    def __init__(self, func: Callable[..., bool | algopy.UInt64], name: str):
         self.func = func
         self.name = name
 
 
 @typing.overload
-def logicsig(sub: Callable[[], bool | algopy.UInt64], /) -> LogicSig: ...
+def logicsig(sub: Callable[_P, bool | algopy.UInt64], /) -> LogicSig: ...
 
 
 @typing.overload
-def logicsig(*, name: str) -> Callable[[Callable[[], bool | algopy.UInt64]], LogicSig]: ...
+def logicsig(
+    *, name: str, **kwargs: typing.Any
+) -> Callable[[Callable[_P, bool | algopy.UInt64]], LogicSig]: ...
 
 
 def logicsig(
-    sub: Callable[[], bool | algopy.UInt64] | None = None, *, name: str | None = None
-) -> algopy.LogicSig | Callable[[Callable[[], bool | algopy.UInt64]], LogicSig]:
+    sub: Callable[_P, bool | algopy.UInt64] | None = None,
+    *,
+    name: str | None = None,
+    **_kwargs: typing.Any,
+) -> algopy.LogicSig | Callable[[Callable[_P, bool | algopy.UInt64]], LogicSig]:
     """Decorator to indicate a function is a logic signature."""
     if sub is None:
         return functools.partial(

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/src/_algopy_testing/op/misc.py

@@ -504,7 +504,7 @@ AppGlobal = _AppGlobal()
 
 
 def arg(a: UInt64 | int, /) -> Bytes:
-    return lazy_context.value._active_lsig_args[int(a)]
+    return Bytes(lazy_context.value._active_lsig_args[int(a)])
 
 
 class Box:

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/src/_algopy_testing/primitives/array.py

@@ -206,6 +206,18 @@ class FixedArray(
         self._items = list(items)
         self._value = serialize_to_bytes(self)
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, self.__class__):
+            return (
+                self._element_type == other._element_type
+                and self._length == other._length
+                and self.serialize() == other.serialize()
+            )
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.serialize())
+
     @classmethod
     def full(cls, item: _TArrayItem) -> typing.Self:
         return cls([item] * cls._length)
@@ -358,6 +370,16 @@ class ImmutableArray(Serializable, typing.Generic[_TArrayItem], metaclass=_Immut
         typ = ImmutableArray[el_type]  # type: ignore[valid-type]
         return typ(items)
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, self.__class__):
+            return (
+                self._element_type == other._element_type and self.serialize() == other.serialize()
+            )
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.serialize())
+
     def __bool__(self) -> bool:
         return bool(self._items)
 
@@ -509,6 +531,16 @@ class Array(Serializable, MutableBytes, typing.Generic[_TArrayItem], metaclass=_
         typ = Array[el_type]  # type: ignore[valid-type]
         return typ(items)
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, self.__class__):
+            return (
+                self._element_type == other._element_type and self.serialize() == other.serialize()
+            )
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.serialize())
+
     def __bool__(self) -> bool:
         return bool(self._items)
 

{algorand_python_testing-1.2.0b8 → algorand_python_testing-1.2.0b10}/src/_algopy_testing/serialize.py

@@ -61,7 +61,7 @@ def get_native_to_arc4_serializer(  # noqa: PLR0911
             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),
+                arc4_to_native=lambda a: typ.from_int(a.as_uint64()),
             )
         if issubclass(typ, FixedBytes):
             length_type = get_type_generic_from_int_literal(typ._length)
@@ -89,8 +89,8 @@ def get_native_to_arc4_serializer(  # noqa: PLR0911
                 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])
+                arc4_to_native=lambda arr: typ(
+                    [element_serializer.arc4_to_native(e) for e in arr]
                 ),
             )
         if issubclass(typ, FixedArray | ImmutableFixedArray):