refactor: simplify attribute access for Asset and Application types (#19)

* refactor: simplify attribute access for Asset and Application types, and handle cases where id's are indexes

* refactor: make internal data structures private on public classes

* fix: Make Global.latest_timestamp constant for a transaction

Author: daniel-makerx

src/_algopy_testing/context_helpers/context_storage.py

@@ -78,13 +78,13 @@ def get_app_data(
 
     def get_asset_data(self, asset_id: int | algopy.UInt64) -> AssetFields:
         try:
-            return self.ledger.asset_data[int(asset_id)]
+            return self.ledger._asset_data[int(asset_id)]
         except KeyError:
             raise ValueError("Unknown asset, check correct testing context is active") from None
 
     def get_account_data(self, account_public_key: str) -> AccountContextData:
         try:
-            return self.ledger.account_data[account_public_key]
+            return self.ledger._account_data[account_public_key]
         except KeyError:
             raise ValueError("Unknown account, check correct testing context is active") from None
 

src/_algopy_testing/context_helpers/ledger_context.py

@@ -23,25 +23,25 @@ class LedgerContext:
     def __init__(self) -> None:
         from _algopy_testing.models.account import AccountContextData, get_empty_account
 
-        self.account_data = defaultdict[str, AccountContextData](get_empty_account)
-        self.app_data: dict[int, ApplicationContextData] = {}
-        self.asset_data: dict[int, AssetFields] = {}
-        self.blocks: dict[int, dict[str, int]] = {}
-        self.global_fields: GlobalFields = get_default_global_fields()
+        self._account_data = defaultdict[str, AccountContextData](get_empty_account)
+        self._app_data: dict[int, ApplicationContextData] = {}
+        self._asset_data: dict[int, AssetFields] = {}
+        self._blocks: dict[int, dict[str, int]] = {}
+        self._global_fields: GlobalFields = get_default_global_fields()
 
         self._asset_id = iter(range(1001, 2**64))
         self._app_id = iter(range(1001, 2**64))
 
-    def get_next_asset_id(self) -> int:
+    def _get_next_asset_id(self) -> int:
         while True:
             asset_id = next(self._asset_id)
-            if asset_id not in self.asset_data:
+            if asset_id not in self._asset_data:
                 return asset_id
 
-    def get_next_app_id(self) -> int:
+    def _get_next_app_id(self) -> int:
         while True:
             app_id = next(self._app_id)
-            if app_id not in self.app_data:
+            if app_id not in self._app_data:
                 return app_id
 
     def get_account(self, address: str) -> algopy.Account:
@@ -68,7 +68,7 @@ def account_exists(self, address: str) -> bool:
             bool: True if the account exists, False otherwise.
         """
         assert_address_is_valid(address)
-        return address in self.account_data
+        return address in self._account_data
 
     def update_account(
         self,
@@ -84,11 +84,11 @@ def update_account(
             **account_fields: The fields to update.
         """
         assert_address_is_valid(address)
-        self.account_data[address].fields.update(account_fields)
+        self._account_data[address].fields.update(account_fields)
 
         if opted_asset_balances is not None:
             for asset_id, balance in opted_asset_balances.items():
-                self.account_data[address].opted_asset_balances[UInt64(asset_id)] = balance
+                self._account_data[address].opted_asset_balances[UInt64(asset_id)] = balance
 
     def get_asset(self, asset_id: algopy.UInt64 | int) -> algopy.Asset:
         """Get an asset by ID.
@@ -105,7 +105,7 @@ def get_asset(self, asset_id: algopy.UInt64 | int) -> algopy.Asset:
         import algopy
 
         asset_id = int(asset_id) if isinstance(asset_id, algopy.UInt64) else asset_id
-        if asset_id not in self.asset_data:
+        if asset_id not in self._asset_data:
             raise ValueError("Asset not found in testing context!")
 
         return algopy.Asset(asset_id)
@@ -122,7 +122,7 @@ def asset_exists(self, asset_id: algopy.UInt64 | int) -> bool:
         import algopy
 
         asset_id = int(asset_id) if isinstance(asset_id, algopy.UInt64) else asset_id
-        return asset_id in self.asset_data
+        return asset_id in self._asset_data
 
     def update_asset(self, asset_id: int, **asset_fields: typing.Unpack[AssetFields]) -> None:
         """Update asset fields.
@@ -134,9 +134,9 @@ def update_asset(self, asset_id: int, **asset_fields: typing.Unpack[AssetFields]
         Raises:
             ValueError: If the asset is not found.
         """
-        if asset_id not in self.asset_data:
+        if asset_id not in self._asset_data:
             raise ValueError("Asset not found in testing context!")
-        self.asset_data[asset_id].update(asset_fields)
+        self._asset_data[asset_id].update(asset_fields)
 
     def get_app(
         self, app_id: algopy.Contract | algopy.Application | algopy.UInt64 | int
@@ -164,7 +164,7 @@ def app_exists(self, app_id: algopy.UInt64 | int) -> bool:
             bool: True if the application exists, False otherwise.
         """
         app_id = _get_app_id(app_id)
-        return app_id in self.app_data
+        return app_id in self._app_data
 
     def update_app(
         self, app_id: int, **application_fields: typing.Unpack[ApplicationFields]
@@ -343,7 +343,7 @@ def set_block(
             seed (algopy.UInt64 | int): The block seed.
             timestamp (algopy.UInt64 | int): The block timestamp.
         """
-        self.blocks[index] = {"seed": int(seed), "timestamp": int(timestamp)}
+        self._blocks[index] = {"seed": int(seed), "timestamp": int(timestamp)}
 
     def get_block_content(self, index: int, key: str) -> int:
         """Get block content.
@@ -358,7 +358,7 @@ def get_block_content(self, index: int, key: str) -> int:
         Raises:
             ValueError: If the block content is not found.
         """
-        content = self.blocks.get(index, {}).get(key, None)
+        content = self._blocks.get(index, {}).get(key, None)
         if content is None:
             raise KeyError(
                 f"Block content for index {index} and key {key} not found in testing context!"
@@ -383,7 +383,7 @@ def patch_global_fields(self, **global_fields: typing.Unpack[GlobalFields]) -> N
                 f"Invalid field(s) found during patch for `Global`: {', '.join(invalid_keys)}"
             )
 
-        self.global_fields.update(global_fields)
+        self._global_fields.update(global_fields)
 
     def _get_app_data(
         self, app: algopy.UInt64 | algopy.Application | algopy.Contract | int
@@ -401,7 +401,7 @@ def _get_app_data(
         """
         app_id = _get_app_id(app)
         try:
-            return self.app_data[app_id]
+            return self._app_data[app_id]
         except KeyError:
             raise ValueError("Unknown app id, is there an active transaction?") from None
 

src/_algopy_testing/context_helpers/txn_context.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import contextlib
+import time
 import typing
 
 import algosdk
@@ -207,6 +208,7 @@ def __init__(
         active_txn_index: int | None = None,
         active_txn_overrides: dict[str, typing.Any] | None = None,
     ):
+        self._latest_timestamp = int(time.time())
         self._set_txn_group(txns, active_txn_index)
         self._itxn_groups: list[Sequence[InnerTransactionResultType]] = []
         self._constructing_itxn_group: list[InnerTransaction] = []

src/_algopy_testing/models/account.py

@@ -82,7 +82,7 @@ def __init__(self, value: str | Bytes = algosdk.constants.ZERO_ADDRESS, /):
     def data(self) -> AccountContextData:
         from _algopy_testing.context_helpers import lazy_context
 
-        return lazy_context.ledger.account_data[self.public_key]
+        return lazy_context.get_account_data(self.public_key)
 
     @property
     def balance(self) -> algopy.UInt64:

src/_algopy_testing/models/application.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-import inspect
 import typing
 
 from _algopy_testing.primitives import UInt64
 from _algopy_testing.protocols import UInt64Backed
-from _algopy_testing.utils import as_int64
+from _algopy_testing.utils import as_int64, resolve_app_index
 
 if typing.TYPE_CHECKING:
     from collections.abc import Sequence
@@ -70,22 +69,15 @@ def from_int(cls, value: int, /) -> typing.Self:
     def fields(self) -> ApplicationFields:
         from _algopy_testing.context_helpers import lazy_context
 
-        if self._id == 0:
-            raise ValueError("cannot access properties of an app with an id of 0") from None
-        return lazy_context.get_app_data(self._id).fields
+        return lazy_context.get_app_data(resolve_app_index(self._id)).fields
 
     def __getattr__(self, name: str) -> typing.Any:
-        if name in inspect.get_annotations(ApplicationFields):
-            value = self.fields.get(name)
-            # TODO: 1.0 ensure reasonable default values are present (like account does)
-            if value is None:
-                raise ValueError(
-                    f"The Application value '{name}' has not been defined on the test context. "
-                    f"Make sure to patch the field '{name}' using your `AlgopyTestContext` "
-                    "instance."
-                )
-            return value
-        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+        try:
+            return self.fields[name]  # type: ignore[literal-required]
+        except KeyError:
+            raise AttributeError(
+                f"'{self.__class__.__name__}' object has no attribute '{name}'"
+            ) from None
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Application):

src/_algopy_testing/models/asset.py

@@ -3,6 +3,7 @@
 import typing
 
 from _algopy_testing.protocols import UInt64Backed
+from _algopy_testing.utils import resolve_asset_index
 
 if typing.TYPE_CHECKING:
     import algopy
@@ -65,39 +66,19 @@ def frozen(self, _account: algopy.Account) -> bool:
             "Please mock this method using your python testing framework of choice."
         )
 
-    def __getattr__(self, name: str) -> object:
+    @property
+    def fields(self) -> AssetFields:
         from _algopy_testing.context_helpers import lazy_context
 
-        if int(self.id) not in lazy_context.ledger.asset_data:
-            # check if its not 0 (which means its not
-            # instantiated/opted-in yet, and instantiated directly
-            # without invoking any_asset).
-            if self.id == 0:
-                # Handle dunder methods specially
-                if name.startswith("__") and name.endswith("__"):
-                    return getattr(type(self), name)
-                # For non-dunder attributes, check in __dict__
-                if name in self.__dict__:
-                    return self.__dict__[name]
-                raise AttributeError(
-                    f"'{self.__class__.__name__}' object has no attribute '{name}'"
-                )
-
-            raise ValueError(
-                "`algopy.Asset` is not present in the test context! "
-                "Use `context.add_asset()` or `context.any.asset()` to add the asset to "
-                "your test setup."
-            )
+        return lazy_context.get_asset_data(resolve_asset_index(self.id))
 
-        return_value = lazy_context.get_asset_data(self.id).get(name)
-        if return_value is None:
+    def __getattr__(self, name: str) -> typing.Any:
+        try:
+            return self.fields[name]  # type: ignore[literal-required]
+        except KeyError:
             raise AttributeError(
-                f"The value for '{name}' in the test context is None. "
-                f"Make sure to patch the global field '{name}' using your `AlgopyTestContext` "
-                "instance."
-            )
-
-        return return_value
+                f"'{self.__class__.__name__}' object has no attribute '{name}'"
+            ) from None
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Asset):

src/_algopy_testing/op/global_values.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import time
 import typing
 from typing import TypedDict, TypeVar
 
@@ -38,7 +37,7 @@ class GlobalFields(TypedDict, total=False):
 class _Global:
     @property
     def _fields(self) -> GlobalFields:
-        return lazy_context.ledger.global_fields
+        return lazy_context.ledger._global_fields
 
     @property
     def current_application_address(self) -> algopy.Account:
@@ -60,8 +59,7 @@ def latest_timestamp(self) -> algopy.UInt64:
         try:
             return self._fields["latest_timestamp"]
         except KeyError:
-            # TODO: 1.0 Construct this while setting default values rather than here.
-            return UInt64(int(time.time()))
+            return UInt64(lazy_context.active_group._latest_timestamp)
 
     @property
     def group_size(self) -> algopy.UInt64:

src/_algopy_testing/op/misc.py

@@ -10,7 +10,11 @@
 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.utils import raise_mocked_function_error
+from _algopy_testing.utils import (
+    raise_mocked_function_error,
+    resolve_app_index,
+    resolve_asset_index,
+)
 
 if typing.TYPE_CHECKING:
     import algopy
@@ -23,10 +27,7 @@ def err() -> None:
 def _get_app(app: algopy.Application | algopy.UInt64 | int) -> Application:
     if isinstance(app, Application):
         return app
-    if app >= 1001:
-        return lazy_context.ledger.get_app(app)
-    txn = lazy_context.active_group.active_txn
-    return txn.apps(app)
+    return lazy_context.ledger.get_app(resolve_app_index(app))
 
 
 def _get_account(acc: algopy.Account | algopy.UInt64 | int) -> Account:
@@ -39,10 +40,7 @@ def _get_account(acc: algopy.Account | algopy.UInt64 | int) -> Account:
 def _get_asset(asset: algopy.Asset | algopy.UInt64 | int) -> Asset:
     if isinstance(asset, Asset):
         return asset
-    if asset >= 1001:
-        return lazy_context.ledger.get_asset(asset)
-    txn = lazy_context.active_group.active_txn
-    return txn.assets(asset)
+    return lazy_context.ledger.get_asset(resolve_asset_index(asset))
 
 
 def _get_bytes(b: algopy.Bytes | bytes) -> bytes:

src/_algopy_testing/utils.py

@@ -29,6 +29,28 @@
     from _algopy_testing.op.global_values import GlobalFields
 
 
+def resolve_app_index(app_id_or_index: algopy.UInt64 | int) -> int:
+    from _algopy_testing.context_helpers import lazy_context
+
+    if app_id_or_index >= 1001:
+        app_id = app_id_or_index
+    else:
+        txn = lazy_context.active_group.active_txn
+        app_id = txn.apps(app_id_or_index).id
+    return int(app_id)
+
+
+def resolve_asset_index(asset_id_or_index: algopy.UInt64 | int) -> int:
+    from _algopy_testing.context_helpers import lazy_context
+
+    if asset_id_or_index >= 1001:
+        asset_id = asset_id_or_index
+    else:
+        txn = lazy_context.active_group.active_txn
+        asset_id = txn.assets(asset_id_or_index).id
+    return int(asset_id)
+
+
 def generate_random_int(min_value: int, max_value: int) -> int:
     return secrets.randbelow(max_value - min_value + 1) + min_value