algorand-python-testing 1.2.0b4__tar.gz → 1.2.0b6__tar.gz

{algorand_python_testing-1.2.0b4 → algorand_python_testing-1.2.0b6}/CHANGELOG.md

@@ -1,4 +1,28 @@
 # CHANGELOG
+## v1.2.0-beta.6 (2026-04-07)
+
+### Features
+
+* add arc65 support: loggedErr() and loggedAssert() functions, to log a formatted error string before failing ([`5ac27a5`](https://github.com/algorandfoundation/algorand-python-testing/commit/5ac27a5f96d075224c47dc7c8b6ceba65db0e5e3))
+
+## 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)

{algorand_python_testing-1.2.0b4 → algorand_python_testing-1.2.0b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: algorand-python-testing
-Version: 1.2.0b4
+Version: 1.2.0b6
 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.0b4 → algorand_python_testing-1.2.0b6}/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              |
@@ -39,6 +41,8 @@ See which `algorand-python` stubs are implemented by the `algorand-python-testin
 | algopy.compile_logicsig                     | Mockable            |
 | algopy.ensure_budget                        | Emulated            |
 | algopy.log                                  | Emulated            |
+| algopy.logged_assert                        | Emulated            |
+| algopy.log_err                              | Emulated            |
 | algopy.logicsig                             | Emulated            |
 | algopy.public                               | Emulated            |
 | algopy.size_of                              | Emulated            |

{algorand_python_testing-1.2.0b4 → algorand_python_testing-1.2.0b6}/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.0b4 → algorand_python_testing-1.2.0b6}/pyproject.toml

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

{algorand_python_testing-1.2.0b4 → algorand_python_testing-1.2.0b6}/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.0b4 → algorand_python_testing-1.2.0b6}/src/_algopy_testing/models/contract.py

@@ -37,16 +37,16 @@ class _ContractMeta(type):
     _scratch_slots: typing.Any
     _state_totals: StateTotals | None
     _avm_version: int
-
-    def __init__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
-        super().__init__(*args, **kwargs)
-        cls.global_state_types = dict[str, type]()
+    _global_state_types: dict[str, type]
 
     def __call__(cls, *args: typing.Any, **kwargs: dict[str, typing.Any]) -> object:
+        # cls is both _ContractMeta and a (sub)class of Contract, but mypy can't
+        # handle intersection types (and assumes that cls is just _ContractMeta)
+        assert issubclass(cls, Contract)
         context = lazy_context.value
         app_ref = context.any.application()  # new reference to get a unique app_id
         app_id = app_ref.id.value
-        instance: Contract = cls.__new__(cls, *args, **kwargs)  # type: ignore[arg-type]
+        instance = cls.__new__(cls, *args, **kwargs)
         instance.__app_id__ = app_id
         app_data = lazy_context.get_app_data(app_id)
         app_data.contract = instance
@@ -54,6 +54,9 @@ class _ContractMeta(type):
 
         fields = get_active_txn_fields(app_ref)
         txn = context.any.txn.application_call(**fields)
+        # the below is the key reason for this being a metaclass, rather than overriding
+        # the __new__ method in Contract itself: we get to control the calling of __init__,
+        # and place it inside the following context manager
         with context.txn._maybe_implicit_txn_group([txn]) as active_group:
             if active_group.active_app_id != app_id:
                 raise ValueError(
@@ -64,10 +67,9 @@ class _ContractMeta(type):
                 app_id,
                 creator=creator,
             )
-            instance.__init__(*args, **kwargs)  # type: ignore[misc]
+            cls.__init__(instance, *args, **kwargs)
         app_data.is_creating = _has_create_methods(cls)
 
-        assert isinstance(instance, Contract)
         cls_state_totals = cls._state_totals or StateTotals()
         state_totals = _get_state_totals(instance, cls_state_totals)
         context.ledger.update_app(
@@ -96,6 +98,7 @@ class Contract(metaclass=_ContractMeta):
         state_totals: StateTotals | None = None,
         avm_version: int = 11,
     ):
+        cls._global_state_types = dict[str, type]()  # ensure each subclass gets its own
         cls._name = name or cls.__name__
         cls._scratch_slots = scratch_slots
         cls._state_totals = state_totals
@@ -115,7 +118,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):
@@ -138,14 +141,11 @@ class Contract(metaclass=_ContractMeta):
             return set_is_creating
 
         cls = type(self)
-        assert isinstance(cls, _ContractMeta)
         try:
-            unproxied_global_state_type = cls.global_state_types[name]
+            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,34 +153,37 @@ 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)
-                cls.global_state_types[name] = type(value)
+                cls._global_state_types[name] = type(value)
 
         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 +199,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,7 +229,21 @@ def _get_state_totals(contract: Contract, cls_state_totals: StateTotals) -> _Sta
     )
 
 
-def _has_create_methods(contract_cls: _ContractMeta) -> bool:
+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: type[Contract]) -> bool:
     for method in vars(contract_cls).values():
         if callable(method) and (arc4_meta := maybe_arc4_metadata(method)) and arc4_meta.is_create:
             return True
@@ -236,30 +251,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.0b4 → algorand_python_testing-1.2.0b6}/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.0b6/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"]