algorand-python-testing 1.2.0b3__tar.gz → 1.2.0b5__tar.gz

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/CHANGELOG.md

@@ -1,4 +1,24 @@
 # CHANGELOG
+## v1.2.0-beta.5 (2026-04-01)
+
+### Features
+
+* add LocalMap ([`447cd47`](https://github.com/algorandfoundation/algorand-python-testing/commit/447cd479a24b8a1fc0c91b51a97b222ba1ea27f8))
+
+* add GlobalMap ([`8d75a3b`](https://github.com/algorandfoundation/algorand-python-testing/commit/8d75a3b65a083b6f1484de44a660a58c8abfd2ef))
+
+### Bug fixes
+
+* do not count GlobalMap and LocalMap in stateTotals ([`d7da98a`](https://github.com/algorandfoundation/algorand-python-testing/commit/d7da98a5802e7a6f172c63a8fad5c7bec292b9bc))
+
+* state totals now correctly handle direct tuple storage ([`8e7d214`](https://github.com/algorandfoundation/algorand-python-testing/commit/8e7d21481de91767c25c1311c4b4ee6363af83b9))
+
+### Documentation
+
+* add GlobalMap and LocalMap to state-management guide ([`e8ca7f8`](https://github.com/algorandfoundation/algorand-python-testing/commit/e8ca7f835f66ac0ae1bc6d953d8bdd43cef7e1f5))
+
+## v1.2.0-beta.4 (2026-03-16)
+
 ## v1.2.0-beta.3 (2025-12-08)
 
 ### Features

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/PKG-INFO

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

@@ -20,9 +20,11 @@ See which `algorand-python` stubs are implemented by the `algorand-python-testin
 | algopy.FixedArray                           | Native              |
 | algopy.FixedBytes                           | Native              |
 | algopy.Global                               | Emulated            |
+| algopy.GlobalMap                            | Emulated            |
 | algopy.GlobalState                          | Emulated            |
 | algopy.ImmutableArray                       | Native              |
 | algopy.ImmutableFixedArray                  | Native              |
+| algopy.LocalMap                             | Emulated            |
 | algopy.LocalState                           | Emulated            |
 | algopy.LogicSig                             | Emulated            |
 | algopy.OnCompleteAction                     | Native              |

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/docs/testing-guide/state-management.md

@@ -29,6 +29,42 @@ contract.state_a.value = algopy.UInt64(10)
 contract.state_b.value = algopy.UInt64(20)
 ```
 
+## Global Map
+
+`GlobalMap` allows contracts to store collections of key-value pairs in global state, using a common key type and value type with an automatically derived (or explicit) key prefix.
+
+```{testcode}
+class GlobalMapContract(algopy.ARC4Contract):
+    def __init__(self):
+        # Implicit key prefix (derived from attribute name "scores")
+        self.scores = algopy.GlobalMap(algopy.Bytes, algopy.arc4.UInt64)
+        # Explicit key prefix
+        self.labels = algopy.GlobalMap(algopy.Bytes, algopy.arc4.String, key_prefix="my_labels")
+
+# In your test
+contract = GlobalMapContract()
+
+# Set and get values
+contract.scores[algopy.Bytes(b"item_a")] = algopy.arc4.UInt64(100)
+assert contract.scores[algopy.Bytes(b"item_a")] == algopy.arc4.UInt64(100)
+
+# Check existence
+assert algopy.Bytes(b"item_a") in contract.scores
+assert algopy.Bytes(b"item_b") not in contract.scores
+
+# Get with default
+result = contract.scores.get(algopy.Bytes(b"item_b"), default=algopy.arc4.UInt64(0))
+assert result == algopy.arc4.UInt64(0)
+
+# Maybe (returns value and existence flag)
+value, exists = contract.scores.maybe(algopy.Bytes(b"item_a"))
+assert exists
+
+# Delete
+del contract.scores[algopy.Bytes(b"item_a")]
+assert algopy.Bytes(b"item_a") not in contract.scores
+```
+
 ## Local State
 
 Local state is defined similarly to global state, but accessed using account addresses as keys.
@@ -44,6 +80,47 @@ account = context.any.account()
 contract.local_state_a[account] = algopy.UInt64(10)
 ```
 
+## Local Map
+
+`LocalMap` is similar to `GlobalMap` but stores per-account state. Values are accessed using an `(account, key)` tuple.
+
+```{testcode}
+class LocalMapContract(algopy.ARC4Contract):
+    def __init__(self):
+        self.balances = algopy.LocalMap(algopy.Bytes, algopy.arc4.UInt64)
+
+# In your test
+contract = LocalMapContract()
+account = context.any.account()
+
+# Set and get values using (account, key) tuple
+contract.balances[account, algopy.Bytes(b"item_a")] = algopy.arc4.UInt64(500)
+assert contract.balances[account, algopy.Bytes(b"item_a")] == algopy.arc4.UInt64(500)
+
+# Check existence
+assert (account, algopy.Bytes(b"item_a")) in contract.balances
+assert (account, algopy.Bytes(b"item_b")) not in contract.balances
+
+# Get with default
+result = contract.balances.get(account, algopy.Bytes(b"item_b"), default=algopy.arc4.UInt64(0))
+assert result == algopy.arc4.UInt64(0)
+
+# Maybe
+value, exists = contract.balances.maybe(account, algopy.Bytes(b"item_a"))
+assert exists
+
+# Delete
+del contract.balances[account, algopy.Bytes(b"item_a")]
+assert (account, algopy.Bytes(b"item_a")) not in contract.balances
+
+# Different accounts have independent state
+account2 = context.any.account()
+contract.balances[account, algopy.Bytes(b"item_a")] = algopy.arc4.UInt64(100)
+contract.balances[account2, algopy.Bytes(b"item_a")] = algopy.arc4.UInt64(200)
+assert contract.balances[account, algopy.Bytes(b"item_a")] == algopy.arc4.UInt64(100)
+assert contract.balances[account2, algopy.Bytes(b"item_a")] == algopy.arc4.UInt64(200)
+```
+
 ## Boxes
 
 The framework supports various Box abstractions available in `algorand-python`.

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "algorand-python-testing"
-version = "1.2.0-beta.3"
+version = "1.2.0-beta.5"
 description = 'Algorand Python testing library'
 readme = "README.md"
 requires-python = ">=3.12"
@@ -50,7 +50,7 @@ type = "virtual"
 path = ".venv"
 python = "3.12"
 dependencies = [
-    "puyapy>=5",
+    "puyapy>=5.7.1",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",
@@ -58,7 +58,7 @@ dependencies = [
     "algokit-utils>=4.0.0",
     "pytest-cov>=4.1.0",
     "prettytable>=3.9.0",
-    "mypy==1.10",
+    "mypy==1.19.1",
 ]
 
 [tool.hatch.envs.default.env-vars]
@@ -132,7 +132,7 @@ dependencies = [
     "pytest-cov>=4.1.0",
     "py-algorand-sdk>=2.4.0",
     "algokit-utils>=4.0.0",
-    "puyapy>=5",
+    "puyapy>=5.7.1",
 ]
 
 [tool.hatch.envs.test.scripts]
@@ -190,7 +190,7 @@ dependencies = [
     "py-algorand-sdk>=2.4.0",
     "algokit-utils>=4.0.0",
     "pytest-cov>=4.1.0",
-    "mypy==1.10",
+    "mypy==1.19.1",
 ]
 
 [tool.hatch.envs.examples.scripts]

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/src/_algopy_testing/__init__.py

@@ -21,7 +21,7 @@ from _algopy_testing.models import (
     urange,
 )
 from _algopy_testing.primitives import BigUInt, Bytes, FixedBytes, String, UInt64
-from _algopy_testing.state import Box, BoxMap, BoxRef, GlobalState, LocalState
+from _algopy_testing.state import Box, BoxMap, BoxRef, GlobalMap, GlobalState, LocalMap, LocalState
 from _algopy_testing.value_generators.arc4 import ARC4ValueGenerator
 from _algopy_testing.value_generators.avm import AVMValueGenerator
 from _algopy_testing.value_generators.txn import TxnValueGenerator
@@ -44,10 +44,12 @@ __all__ = [
     "Bytes",
     "Contract",
     "FixedBytes",
+    "GlobalMap",
     "GlobalState",
     "ITxnGroupLoader",
     "ITxnLoader",
     "LedgerContext",
+    "LocalMap",
     "LocalState",
     "LogicSig",
     "OnCompleteAction",

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/src/_algopy_testing/arc4.py

@@ -1154,17 +1154,17 @@ class _StructMeta(type):
 
 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)
+    return parameterize_type(Tuple, *field_types)  # type: ignore[arg-type]
 
 
-class Struct(MutableBytes, _ABIEncoded, metaclass=_StructMeta):  # type: ignore[misc]
+class Struct(MutableBytes, _ABIEncoded, metaclass=_StructMeta):
     """Base class for ARC4 Struct types."""
 
     _type_info: typing.ClassVar[_StructTypeInfo]  # type: ignore[misc]
 
     def __init_subclass__(cls, *args: typing.Any, **kwargs: dict[str, typing.Any]) -> None:
         # make implementation not frozen, so we can conditionally control behaviour
-        dataclasses.dataclass(cls, *args, **{**kwargs, "frozen": False})
+        dataclasses.dataclass(cls, *args, **{**kwargs, "frozen": False})  # type: ignore[call-overload]
         frozen = kwargs.get("frozen", False)
         assert isinstance(frozen, bool)
         cls._type_info = _StructTypeInfo(cls, frozen=frozen)

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/src/_algopy_testing/itxn_loader.py

@@ -48,7 +48,7 @@ class ITxnLoader:
     def _get_itxn(self, txn_type: type[_T]) -> _T:
         if (
             not isinstance(self._inner_txn, txn_type)
-            and getattr(self._inner_txn, "type", None) != self._TXN_TYPE_MAP[txn_type]
+            and getattr(self._inner_txn, "type", None) != self._TXN_TYPE_MAP[txn_type]  # type: ignore[index]
         ):
             raise TypeError(f"transaction is not of type {txn_type.__name__}!")
         return self._inner_txn  # type: ignore[return-value]

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/src/_algopy_testing/models/account.py

@@ -75,7 +75,7 @@ class AccountContextData:
 
     opted_assets: dict[int, AssetHolding] = dataclasses.field(default_factory=dict)
     opted_apps: dict[int, algopy.Application] = dataclasses.field(default_factory=dict)
-    fields: AccountFields = dataclasses.field(default_factory=AccountFields)  # type: ignore[arg-type]
+    fields: AccountFields = dataclasses.field(default_factory=AccountFields)
 
 
 class Account(BytesBacked):

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/src/_algopy_testing/models/contract.py

@@ -115,7 +115,7 @@ class Contract(metaclass=_ContractMeta):
 
             def create_txn_group(*args: typing.Any, **kwargs: dict[str, typing.Any]) -> typing.Any:
                 context = lazy_context.value
-                app = context.ledger.get_app(_get_self_or_active_app_id(self))
+                app = context.ledger.get_app(self.__app_id__)
                 txn_fields = get_active_txn_fields(app)
                 txns = [context.any.txn.application_call(**txn_fields)]
                 with context.txn._maybe_implicit_txn_group(txns):
@@ -143,9 +143,7 @@ class Contract(metaclass=_ContractMeta):
             unproxied_global_state_type = cls.global_state_types[name]
         except KeyError:
             return attr
-        value = lazy_context.ledger.get_global_state(
-            _get_self_or_active_app_id(self), name.encode("utf8")
-        )
+        value = lazy_context.ledger.get_global_state(self.__app_id__, name.encode("utf8"))
 
         value = deserialize(unproxied_global_state_type, value)
         return set_attr_on_mutate(self, name, value)
@@ -153,20 +151,26 @@ class Contract(metaclass=_ContractMeta):
     def __setattr__(self, name: str, value: typing.Any) -> None:
         name_bytes = _algopy_testing.String(name).bytes
         match value:
-            case (_algopy_testing.Box() | _algopy_testing.BoxRef()) as box if not box._key:
-                box._key = name_bytes
+            case (_algopy_testing.Box() | _algopy_testing.BoxRef()) as box:
+                if not box._key:
+                    box._key = name_bytes
+            case _algopy_testing.BoxMap() as box_map:
+                if box_map._key_prefix is None:
+                    box_map._key_prefix = name_bytes
             case _algopy_testing.GlobalState() as state:
-                state.app_id = _get_self_or_active_app_id(self)
+                state.app_id = self.__app_id__
                 if not state._key:
                     state.set_key(name_bytes)
             case _algopy_testing.LocalState() as state:
-                state.app_id = _get_self_or_active_app_id(self)
+                state.app_id = self.__app_id__
                 if not state._key:
                     state._key = name_bytes
-            case _algopy_testing.BoxMap() as box_map if box_map._key_prefix is None:
-                box_map._key_prefix = name_bytes
-            case Bytes() | UInt64() | BytesBacked() | Serializable() | UInt64Backed() | bool():
-                app_id = _get_self_or_active_app_id(self)
+            case _algopy_testing.GlobalMap() | _algopy_testing.LocalMap() as state_map:
+                state_map.app_id = self.__app_id__
+                if state_map._key_prefix is None:
+                    state_map._key_prefix = name_bytes
+            case _ if _is_data_type(value):
+                app_id = self.__app_id__
                 lazy_context.ledger.set_global_state(app_id, name_bytes, serialize(value))
                 cls = type(self)
                 assert isinstance(cls, _ContractMeta)
@@ -175,12 +179,10 @@ class Contract(metaclass=_ContractMeta):
         super().__setattr__(name, value)
 
 
-def _get_self_or_active_app_id(contract: Contract) -> int:
-    try:
-        return contract.__app_id__
-    # during construction app_id is not available, get from context instead
-    except AttributeError:
-        return lazy_context.active_group.active_app_id
+def _is_data_type(value: object) -> bool:
+    return isinstance(
+        value, Bytes | UInt64 | BytesBacked | Serializable | UInt64Backed | bool | tuple
+    )
 
 
 class ARC4Contract(Contract):
@@ -196,17 +198,15 @@ class ARC4Contract(Contract):
 
 
 def _get_state_totals(contract: Contract, cls_state_totals: StateTotals) -> _StateTotals:
-    from _algopy_testing.primitives import UInt64
-    from _algopy_testing.protocols import UInt64Backed
-
     global_bytes = global_uints = local_bytes = local_uints = 0
-    for type_ in get_global_states(contract).values():
-        if isinstance(type_, type) and issubclass(type_, UInt64 | UInt64Backed | bool):
+    state_types = get_state_types(contract)
+    for type_ in state_types.global_types:
+        if _is_uint_state(type_):
             global_uints += 1
         else:
             global_bytes += 1
-    for type_ in get_local_states(contract).values():
-        if isinstance(type_, type) and issubclass(type_, UInt64 | UInt64Backed | bool):
+    for type_ in state_types.local_types:
+        if _is_uint_state(type_):
             local_uints += 1
         else:
             local_bytes += 1
@@ -228,6 +228,20 @@ def _get_state_totals(contract: Contract, cls_state_totals: StateTotals) -> _Sta
     )
 
 
+def _is_uint_state(type_: type) -> bool:
+    from _algopy_testing.primitives import UInt64
+    from _algopy_testing.protocols import UInt64Backed
+
+    # check to make sure it's actually a type first, otherwise issubclass will
+    # fail on Python 3.13
+    if not isinstance(type_, type):
+        # this should only occur for tuples, bit of a hole in the type-system
+        assert typing.get_origin(type_) is tuple
+        return False
+    else:
+        return issubclass(type_, UInt64 | UInt64Backed | bool)
+
+
 def _has_create_methods(contract_cls: _ContractMeta) -> bool:
     for method in vars(contract_cls).values():
         if callable(method) and (arc4_meta := maybe_arc4_metadata(method)) and arc4_meta.is_create:
@@ -236,30 +250,20 @@ def _has_create_methods(contract_cls: _ContractMeta) -> bool:
     return False
 
 
-def get_local_states(contract: Contract) -> dict[bytes, type]:
-    local_states = {
-        attribute._key.value: attribute.type_
-        for _, attribute in vars(contract).items()
-        if isinstance(attribute, _algopy_testing.LocalState)
-    }
-
-    return local_states
-
-
-def get_global_states(contract: Contract) -> dict[bytes, type]:
-    global_states = {}
-    for key, attribute in vars(contract).items():
-        if isinstance(
-            attribute,
-            _algopy_testing.LocalState
-            | _algopy_testing.Box
-            | _algopy_testing.BoxMap
-            | _algopy_testing.BoxRef,
-        ) or callable(attribute):
-            continue
-        if isinstance(attribute, _algopy_testing.GlobalState):
-            global_states[attribute.key.value] = attribute.type_
-        elif isinstance(attribute, UInt64Backed | BytesBacked | UInt64 | Bytes | bool):
-            global_states[key.encode()] = type(attribute)
-
-    return global_states
+@dataclass
+class _StateTypes:
+    local_types: list[type]
+    global_types: list[type]
+
+
+def get_state_types(contract: Contract) -> _StateTypes:
+    result = _StateTypes(local_types=[], global_types=[])
+    for attribute in contract.__dict__.values():
+        match attribute:
+            case _algopy_testing.LocalState(type_=value_type):
+                result.local_types.append(value_type)
+            case _algopy_testing.GlobalState(type_=value_type):
+                result.global_types.append(value_type)
+            case _ if _is_data_type(attribute):
+                result.global_types.append(type(attribute))
+    return result

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/src/_algopy_testing/op/misc.py

@@ -10,6 +10,7 @@ from _algopy_testing.enums import TransactionType
 from _algopy_testing.models import Account, Application, Asset
 from _algopy_testing.primitives.bytes import Bytes
 from _algopy_testing.primitives.uint64 import UInt64
+from _algopy_testing.state.utils import get_account
 from _algopy_testing.utils import (
     raise_mocked_function_error,
     resolve_app_index,
@@ -30,13 +31,6 @@ def _get_app(app: algopy.Application | algopy.UInt64 | int) -> Application:
     return lazy_context.ledger.get_app(resolve_app_index(app))
 
 
-def _get_account(acc: algopy.Account | algopy.UInt64 | int) -> Account:
-    if isinstance(acc, Account):
-        return acc
-    txn = lazy_context.active_group.active_txn
-    return txn.accounts(acc)
-
-
 def _get_asset(asset: algopy.Asset | algopy.UInt64 | int) -> Asset:
     if isinstance(asset, Asset):
         return asset
@@ -88,12 +82,12 @@ def gaid(a: algopy.UInt64 | int, /) -> algopy.UInt64:
 
 
 def balance(a: algopy.Account | algopy.UInt64 | int, /) -> algopy.UInt64:
-    account = _get_account(a)
+    account = get_account(a)
     return account.balance
 
 
 def min_balance(a: algopy.Account | algopy.UInt64 | int, /) -> algopy.UInt64:
-    account = _get_account(a)
+    account = get_account(a)
     return account.min_balance
 
 
@@ -104,7 +98,7 @@ def exit(_a: UInt64 | int, /) -> typing.Never:  # noqa: A001
 def app_opted_in(
     a: algopy.Account | algopy.UInt64 | int, b: algopy.Application | algopy.UInt64 | int, /
 ) -> bool:
-    account = _get_account(a)
+    account = get_account(a)
     app = _get_app(b)
 
     return account.is_opted_in(app)
@@ -113,100 +107,100 @@ def app_opted_in(
 class AcctParamsGet:
     @staticmethod
     def acct_auth_addr(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.Account, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.auth_address, account.balance != 0
 
     @staticmethod
     def acct_balance(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.balance, account.balance != 0
 
     @staticmethod
     def acct_min_balance(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.min_balance, account.balance != 0
 
     @staticmethod
     def acct_auth_address(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.auth_address, account.balance != 0
 
     @staticmethod
     def acct_total_num_uint(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_num_uint, account.balance != 0
 
     @staticmethod
     def acct_total_num_byte_slice(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_num_byte_slice, account.balance != 0
 
     @staticmethod
     def acct_total_extra_app_pages(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_extra_app_pages, account.balance != 0
 
     @staticmethod
     def acct_total_apps_created(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_apps_created, account.balance != 0
 
     @staticmethod
     def acct_total_apps_opted_in(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_apps_opted_in, account.balance != 0
 
     @staticmethod
     def acct_total_assets_created(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_assets_created, account.balance != 0
 
     @staticmethod
     def acct_total_assets(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_assets, account.balance != 0
 
     @staticmethod
     def acct_total_boxes(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_boxes, account.balance != 0
 
     @staticmethod
     def acct_total_box_bytes(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.total_box_bytes, account.balance != 0
 
     @staticmethod
     def acct_incentive_eligible(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[bool, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.incentive_eligible, account.balance != 0
 
     @staticmethod
     def acct_last_heartbeat(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.last_heartbeat, account.balance != 0
 
     @staticmethod
     def acct_last_proposed(
         a: algopy.Account | algopy.UInt64 | int,
     ) -> tuple[algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         return account.last_proposed, account.balance != 0
 
 
@@ -316,7 +310,7 @@ class _AssetHoldingGet:
         field: str,
     ) -> tuple[typing.Any, bool]:
         # Resolve account
-        account = _get_account(account_or_index)
+        account = get_account(account_or_index)
         try:
             asset = _get_asset(asset_or_index)
         except ValueError:
@@ -427,7 +421,7 @@ class _AppLocal:
         c: algopy.Bytes | bytes,
         /,
     ) -> tuple[algopy.Bytes | algopy.UInt64, bool]:
-        account = _get_account(a)
+        account = get_account(a)
         app = _get_app(b)
         key = _get_bytes(c)
         try:
@@ -444,7 +438,7 @@ class _AppLocal:
     get_ex_uint64 = get_ex_bytes
 
     def delete(self, a: algopy.Account | algopy.UInt64 | int, b: algopy.Bytes | bytes, /) -> None:
-        account = _get_account(a)
+        account = get_account(a)
         key = _get_bytes(b)
         lazy_context.ledger.set_local_state(lazy_context.active_app_id, account, key, None)
 
@@ -455,7 +449,7 @@ class _AppLocal:
         c: algopy.Bytes | algopy.UInt64 | bytes | int,
         /,
     ) -> None:
-        account = _get_account(a)
+        account = get_account(a)
         key = _get_bytes(b)
         value = c.value if isinstance(c, Bytes | UInt64) else c
         lazy_context.ledger.set_local_state(lazy_context.active_app_id, account, key, value)

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/src/_algopy_testing/primitives/array.py

@@ -531,7 +531,7 @@ class Struct(Serializable, MutableBytes):
 
     def __init_subclass__(cls, *args: typing.Any, **kwargs: dict[str, typing.Any]) -> None:
         # make implementation not frozen, so we can conditionally control behaviour
-        dataclasses.dataclass(cls, *args, **{**kwargs, "frozen": False})
+        dataclasses.dataclass(cls, *args, **{**kwargs, "frozen": False})  # type: ignore[call-overload]
         frozen = kwargs.get("frozen", False)
         cls._field_names = [
             f.name for f in dataclasses.fields(typing.cast("type[DataclassInstance]", cls))

{algorand_python_testing-1.2.0b3 → algorand_python_testing-1.2.0b5}/src/_algopy_testing/serialize.py

@@ -145,7 +145,7 @@ def _get_tuple_serializer(item_types: tuple[type, ...]) -> _Serializer[typing.An
         return tuple(result)
 
     return _Serializer(
-        arc4_type=arc4.Tuple[*(s.arc4_type for s in serializers)],  # type: ignore[misc]
+        arc4_type=arc4.Tuple[*(s.arc4_type for s in serializers)],  # type: ignore[misc,arg-type]
         native_to_arc4=lambda t: arc4.Tuple(_items_to_arc4(t)),
         arc4_to_native=lambda t: _items_to_native(t),
     )
@@ -190,7 +190,7 @@ def type_of(value: object) -> type:
     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]
+        return tuple[*(type_of(i) for i in value)]  # type: ignore[misc,return-value]
     else:
         return type(value)
 

algorand_python_testing-1.2.0b5/src/_algopy_testing/state/__init__.py

@@ -0,0 +1,7 @@
+from _algopy_testing.state.box import Box, BoxMap, BoxRef
+from _algopy_testing.state.global_map import GlobalMap
+from _algopy_testing.state.global_state import GlobalState
+from _algopy_testing.state.local_map import LocalMap
+from _algopy_testing.state.local_state import LocalState
+
+__all__ = ["Box", "BoxMap", "BoxRef", "GlobalMap", "GlobalState", "LocalMap", "LocalState"]