algorand-python-testing 1.1.0__tar.gz → 1.2.0b1__tar.gz

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/CHANGELOG.md

@@ -1,4 +1,10 @@
 # CHANGELOG
+## v1.2.0-beta.1 (2025-12-05)
+
+### Features
+
+* add fixed size variant of bytes as a separate `FixedBytes` type ([`9a2ab8e`](https://github.com/algorandfoundation/algorand-python-testing/commit/9a2ab8e3f94e9e7a2a416a94a54cf51b57599089))
+
 ## v1.1.0 (2025-10-20)
 
 ## v1.1.0-beta.1 (2025-10-20)

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: algorand-python-testing
-Version: 1.1.0
+Version: 1.2.0b1
 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.1.0 → algorand_python_testing-1.2.0b1}/docs/coverage.md

@@ -3,7 +3,7 @@
 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 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            |
@@ -18,6 +18,7 @@ See which `algorand-python` stubs are implemented by the `algorand-python-testin
 | algopy.CompiledLogicSig                     | Mockable            |
 | algopy.Contract                             | Emulated            |
 | algopy.FixedArray                           | Native              |
+| algopy.FixedBytes                           | Native              |
 | algopy.Global                               | Emulated            |
 | algopy.GlobalState                          | Emulated            |
 | algopy.ImmutableArray                       | Native              |

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/docs/testing-guide/avm-types.md

@@ -50,6 +50,22 @@ random_bytes = context.any.bytes()
 random_bytes = context.any.bytes(length=32)
 ```
 
+## FixedBytes
+
+```{testcode}
+import typing
+
+# Direct instantiation
+bytes_value = algopy.FixedBytes[typing.Literal[16]](b"Hello, Algorand!")
+
+
+# Instantiate test context
+...
+
+# Generate random byte sequences of length 32
+random_bytes = context.any.fixed_bytes(algopy.FixedBytes[typing.Literal[32]])
+```
+
 ## String
 
 ```{testcode}

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/pyproject.toml

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

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/_algopy_testing/__init__.py

@@ -19,7 +19,7 @@ from _algopy_testing.models import (
     uenumerate,
     urange,
 )
-from _algopy_testing.primitives import BigUInt, Bytes, String, UInt64
+from _algopy_testing.primitives import BigUInt, Bytes, FixedBytes, String, UInt64
 from _algopy_testing.state import Box, BoxMap, BoxRef, GlobalState, LocalState
 from _algopy_testing.value_generators.arc4 import ARC4ValueGenerator
 from _algopy_testing.value_generators.avm import AVMValueGenerator
@@ -39,6 +39,7 @@ __all__ = [
     "BoxRef",
     "Bytes",
     "Contract",
+    "FixedBytes",
     "GlobalState",
     "ITxnGroupLoader",
     "ITxnLoader",

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/_algopy_testing/decorators/arc4.py

@@ -12,7 +12,7 @@ import _algopy_testing
 from _algopy_testing.constants import ALWAYS_APPROVE_TEAL_PROGRAM, ARC4_RETURN_PREFIX
 from _algopy_testing.context_helpers import lazy_context
 from _algopy_testing.enums import OnCompleteAction
-from _algopy_testing.primitives import BigUInt, Bytes, String, UInt64
+from _algopy_testing.primitives import BigUInt, Bytes, FixedBytes, String, UInt64
 
 _P = typing.ParamSpec("_P")
 _R = typing.TypeVar("_R")
@@ -418,6 +418,8 @@ def _type_to_arc4(  # noqa: PLR0912 PLR0911
         return "uint512"
     if issubclass(annotation, Bytes):
         return "byte[]"
+    if issubclass(annotation, FixedBytes):
+        return f"byte[{annotation._length}]"
     if issubclass(annotation, bool):
         return "bool"
     raise TypeError(f"type not a valid ARC4 type: {annotation}")

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/_algopy_testing/primitives/__init__.py

@@ -9,6 +9,7 @@ from _algopy_testing.primitives.array import (
 )
 from _algopy_testing.primitives.biguint import BigUInt
 from _algopy_testing.primitives.bytes import Bytes
+from _algopy_testing.primitives.fixed_bytes import FixedBytes
 from _algopy_testing.primitives.string import String
 from _algopy_testing.primitives.uint64 import UInt64
 
@@ -17,6 +18,7 @@ __all__ = [
     "BigUInt",
     "Bytes",
     "FixedArray",
+    "FixedBytes",
     "ImmutableArray",
     "ImmutableFixedArray",
     "ReferenceArray",

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/_algopy_testing/primitives/bytes.py

@@ -7,6 +7,8 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
+    from _algopy_testing.primitives.fixed_bytes import FixedBytes
+
 
 from itertools import zip_longest
 
@@ -27,7 +29,7 @@ class Bytes:
         check_type(value, bytes)
         self.value = as_bytes(value)
 
-    def __contains__(self, item: Bytes | bytes) -> bool:
+    def __contains__(self, item: Bytes | FixedBytes | bytes) -> bool:  # type: ignore[type-arg]
         item_bytes = as_bytes(item)
         return item_bytes in self.value
 
@@ -43,11 +45,8 @@ class Bytes:
     def __add__(self, other: Bytes | bytes) -> Bytes:
         """Concatenate Bytes with another Bytes or bytes literal e.g. `Bytes(b"Hello ")
         + b"World"`."""
-        if isinstance(other, Bytes):
-            return _checked_result(self.value + other.value, "+")
-        else:
-            result = self.value + as_bytes(other)
-            return _checked_result(result, "+")
+        result = self.value + as_bytes(other)
+        return _checked_result(result, "+")
 
     def __radd__(self, other: bytes) -> Bytes:
         """Concatenate Bytes with another Bytes or bytes literal e.g. `b"Hello " +
@@ -70,7 +69,7 @@ class Bytes:
         self, index: UInt64 | int | slice
     ) -> Bytes:  # maps to substring/substring3 if slice, extract/extract3 otherwise?
         """Returns a Bytes containing a single byte if indexed with UInt64 or int
-        otherwise the substring o bytes described by the slice."""
+        otherwise the substring of bytes described by the slice."""
         if isinstance(index, slice):
             return Bytes(self.value[index])
         else:
@@ -181,7 +180,7 @@ def _checked_result(result: bytes, op: str) -> Bytes:
     """Ensures `result` is a valid Bytes value.
 
     Raises:
-        ArithmeticError: If `result` of `op` is out of bounds
+        OverflowError: If `result` of `op` is out of bounds
     """
     if len(result) > MAX_BYTES_SIZE:
         raise OverflowError(f"{op} overflows")

algorand_python_testing-1.2.0b1/src/_algopy_testing/primitives/fixed_bytes.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+import base64
+import operator
+import types
+import typing
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+
+from itertools import zip_longest
+
+from _algopy_testing.constants import MAX_BYTES_SIZE
+from _algopy_testing.primitives.bytes import Bytes
+from _algopy_testing.primitives.uint64 import UInt64
+from _algopy_testing.protocols import BytesBacked
+from _algopy_testing.utils import (
+    as_bytes,
+    get_int_literal_from_type_generic,
+    get_type_generic_from_int_literal,
+)
+
+_TBytesLength = typing.TypeVar("_TBytesLength", bound=int)
+_TBytesLength_Arg = typing.TypeVar("_TBytesLength_Arg", bound=int)
+
+
+def _get_or_create_class_from_type(cls: type, length_t: type) -> type:
+    _length = get_int_literal_from_type_generic(length_t)
+    return _get_or_create_class(cls, _length, length_t)
+
+
+def _get_or_create_class_from_int(cls: type, length: int) -> type:
+    length_t = get_type_generic_from_int_literal(length)
+    return _get_or_create_class(cls, length, length_t)
+
+
+def _get_or_create_class(cls: type, length: int, length_t: type) -> type:
+    """Get or create a type that is parametrized with element_t and length."""
+    cache = getattr(cls, "__concrete__", {})
+    if c := cache.get(length_t, None):
+        assert isinstance(c, type)
+        return c
+
+    cls_name = f"{cls.__name__}[{length}]"
+
+    cache[length_t] = t = types.new_class(
+        cls_name,
+        bases=(cls,),
+        exec_body=lambda ns: ns.update(
+            _length=length,
+        ),
+    )
+    return t
+
+
+class _FixedBytesMeta(type):
+    __concrete__: typing.ClassVar[dict[type, type]] = {}
+
+    def __getitem__(cls, length_t: type) -> type:
+        if length_t == typing.Any:
+            return cls
+
+        return _get_or_create_class_from_type(cls, length_t)
+
+
+class FixedBytes(
+    BytesBacked,
+    typing.Generic[_TBytesLength],
+    metaclass=_FixedBytesMeta,
+):
+    """A statically-sized byte sequence, where the length is known at compile time.
+
+    Unlike `Bytes`, `FixedBytes` has a fixed length specified via a type parameter.
+
+    Example:
+        FixedBytes[typing.Literal[32]]  # A 32-byte fixed-size bytes value
+    """
+
+    value: bytes  # underlying 'bytes' value representing the FixedBytes
+    _length: int
+
+    def __init__(self, value: Bytes | bytes | None = None, /):
+        if value is None:
+            self.value = b"\x00" * self._length
+            return
+
+        self.value = as_bytes(value)
+        if not hasattr(self, "_length"):
+            self._length = len(self.value)
+
+        if len(self.value) != self._length:
+            raise ValueError(f"expected value of length {self._length}, not {len(self.value)}")
+
+    def __repr__(self) -> str:
+        return repr(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    def __bool__(self) -> bool:
+        return bool(self._length)
+
+    def __len__(self) -> int:
+        return self._length
+
+    def __eq__(self, other: FixedBytes[_TBytesLength_Arg] | Bytes | bytes) -> bool:  # type: ignore[override]
+        """FixedBytes can be compared using the `==` operator with another FixedBytes,
+        Bytes or bytes."""
+
+        if isinstance(other, FixedBytes) and other.length != self.length:
+            return False
+
+        try:
+            other_bytes = as_bytes(other)
+        except TypeError:
+            return NotImplemented
+
+        return self.value == other_bytes
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+    def __add__(self, other: FixedBytes[_TBytesLength_Arg] | Bytes | bytes) -> Bytes:
+        """Concatenate FixedBytes with another Bytes or bytes literal e.g.
+        `FixedBytes[typing.Literal[5]](b"Hello ") + b"World"`."""
+        result = self.value + as_bytes(other)
+        return _checked_result(result, "+")
+
+    def __radd__(self, other: FixedBytes[_TBytesLength_Arg] | Bytes | bytes) -> Bytes:
+        """Concatenate FixedBytes with another Bytes or bytes literal e.g. `b"Hello " +
+        FixedBytes[typing.Literal[5]](b"World")`."""
+        result = as_bytes(other) + self.value
+        return _checked_result(result, "+")
+
+    def __iadd__(self, _other: Bytes | typing.Self | bytes) -> typing.Self:  # type: ignore[misc]
+        raise TypeError("FixedBytes does not support in-place addition")
+
+    @property
+    def length(self) -> UInt64:
+        """Returns the specified length of the FixedBytes."""
+        return UInt64(self._length)
+
+    def __getitem__(self, index: UInt64 | int | slice) -> Bytes:
+        """Returns a Bytes containing a single byte if indexed with UInt64 or int
+        otherwise the substring of bytes described by the slice."""
+        value = self.value[: self.length]
+        if isinstance(index, slice):
+            return Bytes(value[index])
+        else:
+            int_index = index.value if isinstance(index, UInt64) else index
+            int_index = self.length.value + int_index if int_index < 0 else int_index
+            if (int_index >= self.length) or (int_index < 0):
+                raise ValueError("FixedBytes index out of range")
+            # my_bytes[0:1] => b'j' whereas my_bytes[0] => 106
+            return Bytes(value[slice(int_index, int_index + 1)])
+
+    def __iter__(self) -> Iterator[Bytes]:
+        """FixedBytes can be iterated, yielding each consecutive byte."""
+        return _FixedBytesIter(self, 1)
+
+    def __reversed__(self) -> Iterator[Bytes]:
+        """FixedBytes can be iterated in reverse, yield each preceding byte starting at
+        the end."""
+        return _FixedBytesIter(self, -1)
+
+    @typing.overload
+    def __and__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
+    @typing.overload
+    def __and__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __and__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> typing.Self | Bytes:
+        """Compute the bitwise AND of the FixedBytes with another FixedBytes, Bytes, or
+        bytes.
+
+        Returns FixedBytes if other has the same length, otherwise returns Bytes.
+        """
+        return self._operate_bitwise(other, operator.and_)
+
+    def __rand__(self, other: bytes) -> Bytes:
+        return self & other
+
+    def __iand__(self, other: Bytes | typing.Self | bytes) -> typing.Self:  # type: ignore[misc]
+        other_bytes = as_bytes(other)
+        other_fixed_bytes = self.__class__(other_bytes)
+        result = self._operate_bitwise(other_fixed_bytes, operator.and_)
+        assert isinstance(result, self.__class__)
+        return result
+
+    @typing.overload
+    def __or__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
+    @typing.overload
+    def __or__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __or__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> typing.Self | Bytes:
+        return self._operate_bitwise(other, operator.or_)
+
+    def __ror__(self, other: bytes) -> Bytes:
+        return self | other
+
+    def __ior__(self, other: Bytes | typing.Self | bytes) -> typing.Self:  # type: ignore[misc]
+        other_bytes = as_bytes(other)
+        other_fixed_bytes = self.__class__(other_bytes)
+        result = self._operate_bitwise(other_fixed_bytes, operator.or_)
+        assert isinstance(result, self.__class__)
+        return result
+
+    @typing.overload
+    def __xor__(self, other: typing.Self) -> typing.Self: ...  # type: ignore[overload-overlap]
+    @typing.overload
+    def __xor__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> Bytes: ...
+    def __xor__(self, other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes) -> typing.Self | Bytes:
+        return self._operate_bitwise(other, operator.xor)
+
+    def __rxor__(self, other: bytes) -> Bytes:
+        return self ^ other
+
+    def __ixor__(self, other: Bytes | typing.Self | bytes) -> typing.Self:  # type: ignore[misc]
+        other_bytes = as_bytes(other)
+        other_fixed_bytes = self.__class__(other_bytes)
+        result = self._operate_bitwise(other_fixed_bytes, operator.xor)
+        assert isinstance(result, self.__class__)
+        return result
+
+    def __invert__(self) -> typing.Self:
+        """Compute the bitwise inversion of the FixedBytes.
+
+        Returns:
+            FixedBytes: The result of the bitwise inversion operation.
+        """
+        return self.__class__.from_bytes(bytes(~x + 256 for x in self.value))
+
+    def _operate_bitwise(
+        self,
+        other: FixedBytes[_TBytesLength_Arg] | bytes | Bytes,
+        op: Callable[[int, int], int],
+    ) -> typing.Self | Bytes:
+        maybe_bytes = as_bytes(other)
+        # pad the shorter of self.value and other bytes with leading zero
+        # by reversing them as zip_longest fills at the end
+
+        result = bytes(
+            reversed(
+                bytes(
+                    op(a[0], a[1])
+                    for a in zip_longest(reversed(self.value), reversed(maybe_bytes), fillvalue=0)
+                )
+            )
+        )
+        if isinstance(other, FixedBytes) and len(other.value) == len(self.value):
+            return self.__class__.from_bytes(result)
+        return Bytes(result)
+
+    def __contains__(self, item: FixedBytes[_TBytesLength_Arg] | Bytes | bytes) -> bool:
+        item_bytes = as_bytes(item)
+        return item_bytes in self.value
+
+    @classmethod
+    def from_base32(cls, value: str) -> typing.Self:
+        """Creates FixedBytes from a base32 encoded string e.g.
+        `FixedBytes.from_base32("74======")`"""
+        bytes_value = base64.b32decode(value)
+        c = cls._ensure_class_with_length(bytes_value)
+        return c(bytes_value)
+
+    @classmethod
+    def from_base64(cls, value: str) -> typing.Self:
+        """Creates FixedBytes from a base64 encoded string e.g.
+        `FixedBytes.from_base64("RkY=")`"""
+        bytes_value = base64.b64decode(value)
+        c = cls._ensure_class_with_length(bytes_value)
+        return c(bytes_value)
+
+    @classmethod
+    def from_hex(cls, value: str) -> typing.Self:
+        """Creates FixedBytes from a hex/octal encoded string e.g.
+        `FixedBytes.from_hex("FF")`"""
+        bytes_value = base64.b16decode(value)
+        c = cls._ensure_class_with_length(bytes_value)
+        return c(bytes_value)
+
+    @classmethod
+    def from_bytes(cls, value: Bytes | bytes) -> typing.Self:
+        """Construct an instance from the underlying bytes (no validation)"""
+        bytes_value = value.value if isinstance(value, Bytes) else value
+        c = cls._ensure_class_with_length(bytes_value)
+        result = c()
+        result.value = bytes_value
+        return result
+
+    @classmethod
+    def _ensure_class_with_length(cls, bytes_value: bytes) -> type[typing.Self]:
+        """Returns the appropriate class for the given bytes value.
+
+        If cls has a fixed _length, returns cls. Otherwise, returns or creates a
+        specialized class with the length set to match bytes_value.
+        """
+        return (
+            _get_or_create_class_from_int(cls, len(bytes_value))
+            if not hasattr(cls, "_length")
+            else cls
+        )
+
+    @property
+    def bytes(self) -> Bytes:
+        """Get the underlying Bytes."""
+        return Bytes(self.value)
+
+
+class _FixedBytesIter(typing.Generic[_TBytesLength]):
+    value: FixedBytes[_TBytesLength]
+
+    def __init__(self, sequence: FixedBytes[_TBytesLength], step: int = 1):
+        self.value = sequence
+        self.current = 0 if step > 0 else len(sequence) - 1
+        self.step = step
+        self.myend = len(sequence) - 1 if step > 0 else 0
+
+    def __iter__(self) -> typing.Self:
+        return self
+
+    def __next__(self) -> Bytes:
+        # if current is one step over the end
+        if self.current == self.myend + self.step:
+            raise StopIteration
+
+        self.current += self.step
+        return self.value[self.current - self.step]
+
+
+def _checked_result(result: bytes, op: str) -> Bytes:
+    """Ensures `result` is a valid Bytes value.
+
+    Raises:
+        OverflowError: If `result` of `op` is out of bounds
+    """
+    if len(result) > MAX_BYTES_SIZE:
+        raise OverflowError(f"{op} overflows")
+    return Bytes(result)

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/_algopy_testing/serialize.py

@@ -4,6 +4,7 @@ import inspect
 import typing
 from collections.abc import Callable, Sequence
 
+from _algopy_testing.primitives.fixed_bytes import FixedBytes
 from _algopy_testing.primitives.uint64 import UInt64
 from _algopy_testing.utils import get_type_generic_from_int_literal
 
@@ -62,6 +63,15 @@ def get_native_to_arc4_serializer(  # noqa: PLR0911
                 native_to_arc4=lambda n: arc4.UInt64(n.int_),
                 arc4_to_native=lambda a: typ.from_int(a.native),
             )
+        if issubclass(typ, FixedBytes):
+            length_type = get_type_generic_from_int_literal(typ._length)
+            arc4_static_bytes = arc4.StaticArray[arc4.Byte, length_type]  # type: ignore[valid-type]
+            return _Serializer(
+                arc4_type=arc4_static_bytes,
+                native_to_arc4=lambda n: arc4_static_bytes(*[arc4.Byte.from_bytes(e) for e in n]),
+                arc4_to_native=lambda a: typ(a.bytes),
+            )
+
         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):

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/_algopy_testing/state/utils.py

@@ -42,11 +42,7 @@ def deserialize(typ: type[_TValue], value: SerializableValue) -> _TValue:
         if isinstance(value, bytes):
             raise TypeError("expected int, received bytes")
         return typ.from_int(value)  # type: ignore[return-value]
-    elif issubclass(typ, BytesBacked):
-        if isinstance(value, int):
-            raise TypeError("expected bytes, received int")
-        return typ.from_bytes(Bytes(value))  # type: ignore[return-value]
-    elif issubclass(typ, Serializable):
+    elif issubclass(typ, BytesBacked | Serializable):
         if isinstance(value, int):
             raise TypeError("expected bytes, received int")
         return typ.from_bytes(value)  # type: ignore[return-value]
@@ -70,6 +66,7 @@ def cast_from_bytes(typ: type[_TValue], value: bytes) -> _TValue:
         serialized = as_int64(serialized)
     else:
         serialized = value
+
     return deserialize(typ, serialized)
 
 

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/_algopy_testing/utils.py

@@ -103,6 +103,8 @@ def as_bytes(value: object, *, max_size: int = MAX_BYTES_SIZE) -> bytes:
             pass
         case _algopy_testing.Bytes(value=bytes_value):
             pass
+        case _algopy_testing.FixedBytes(value=bytes_value):
+            pass
         case _:
             raise TypeError(f"value must be a bytes or Bytes type, not {type(value).__name__!r}")
     if len(bytes_value) > max_size:

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/_algopy_testing/value_generators/avm.py

@@ -23,6 +23,8 @@ from _algopy_testing.utils import generate_random_int
 if typing.TYPE_CHECKING:
     import algopy
 
+_TBytesLength = typing.TypeVar("_TBytesLength", bound=int)
+
 
 class AVMValueGenerator:
     """Factory for generating test data for AVM abstractions (uint64, bytes, string,
@@ -198,6 +200,19 @@ class AVMValueGenerator:
         length = length or MAX_BYTES_SIZE
         return _algopy_testing.Bytes(secrets.token_bytes(length))
 
+    def fixed_bytes(
+        self, fixed_bytes_type: type[algopy.FixedBytes[_TBytesLength]]
+    ) -> algopy.FixedBytes[_TBytesLength]:
+        """Generate a random fixed byte sequence of a specified length.
+
+        :param fixed_bytes_type: The FixedBytes type with length parameter (e.g.,
+            FixedBytes[typing.Literal[10]]).
+        :returns: The randomly generated fixed byte sequence.
+        """
+        # Extract the length from the type parameter
+        length = fixed_bytes_type._length
+        return fixed_bytes_type(secrets.token_bytes(length))
+
 
 def _get_app_id(app: algopy.Application | algopy.UInt64 | int) -> int:
     from _algopy_testing.models import Application

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/src/algopy/__init__.py

@@ -19,6 +19,7 @@ from _algopy_testing.primitives import (
     BigUInt,
     Bytes,
     FixedArray,
+    FixedBytes,
     ImmutableArray,
     ImmutableFixedArray,
     ReferenceArray,
@@ -49,6 +50,7 @@ __all__ = [
     "CompiledLogicSig",
     "Contract",
     "FixedArray",
+    "FixedBytes",
     "Global",
     "GlobalState",
     "ImmutableArray",

{algorand_python_testing-1.1.0 → algorand_python_testing-1.2.0b1}/tests/arc4/test_arc4_method_signature.py

@@ -1,3 +1,4 @@
+import typing
 from collections.abc import Generator
 from pathlib import Path
 
@@ -70,17 +71,22 @@ def test_app_args_is_correct_with_simple_args(
     # act
 
     # ensure same execution in AVM runs without errors
-    get_avm_result("sink", value="hello", arr=[1, 2])
+    get_avm_result("sink", value="hello", arr=[1, 2], fixed_bytes=b"test")
     # then run inside emulator
-    contract.sink(arc4.String("hello"), UInt8Array(arc4.UInt8(1), arc4.UInt8(2)))
+    contract.sink(
+        arc4.String("hello"),
+        UInt8Array(arc4.UInt8(1), arc4.UInt8(2)),
+        algopy.FixedBytes[typing.Literal[4]](b"test"),
+    )
 
     # assert
     txn = context.txn.last_active
     app_args = [txn.app_args(i) for i in range(int(txn.num_app_args))]
     assert app_args == [
-        algosdk.abi.Method.from_signature("sink(string,uint8[])void").get_selector(),
+        algosdk.abi.Method.from_signature("sink(string,uint8[],byte[4])void").get_selector(),
         b"\x00\x05hello",
         b"\x00\x02\x01\x02",
+        b"test",
     ]
     assert app_args[0] == arc4.arc4_signature(SignaturesContract.sink)