algorand-python-testing 0.0.0b1__py3-none-any.whl

algopy_testing/models/gtxn.py

@@ -0,0 +1,56 @@
+import typing
+from collections.abc import Callable
+
+
+class _GTxn:
+    def __getattr__(self, name: str) -> Callable[[int], typing.Any]:
+        from algopy_testing.context import get_test_context
+
+        context = get_test_context()
+        if not context:
+            raise ValueError(
+                "Test context is not initialized! Use `with algopy_testing_context()` to access "
+                "the context manager."
+            )
+
+        txn_group = context.get_transaction_group()
+        if not txn_group:
+            raise ValueError(
+                "No group transactions found in the context! Use `with algopy_testing_context()` "
+                "to access the context manager."
+            )
+
+        return lambda *args: self._handle_field(txn_group, name, *args)
+
+    def _handle_field(
+        self, txn_group: list[typing.Any], name: str, *args: typing.Any
+    ) -> typing.Any:
+        if len(args) == 1:
+            return self._get_value(txn_group, name, args[0])
+        elif len(args) == 2:
+            return self._get_value(txn_group, name, args[0], args[1])
+        else:
+            raise ValueError(f"Invalid number of arguments for field '{name}'")
+
+    # TODO: refine mapping
+    def _map_fields(self, name: str) -> str:
+        field_mapping = {"type": "type_bytes", "type_enum": "type", "application_args": "app_args"}
+        return field_mapping.get(name, name)
+
+    def _get_value(
+        self, txn_group: list[typing.Any], name: str, index: int, second_arg: typing.Any = None
+    ) -> object:
+        if index >= len(txn_group):
+            raise IndexError("Transaction index out of range")
+        gtxn = txn_group[index]
+        mapped_name = self._map_fields(name)
+        value = getattr(gtxn, mapped_name)
+
+        if callable(value) and second_arg is not None:
+            return value(second_arg)
+        elif value is None:
+            raise ValueError(f"'{name}' is not defined for {type(gtxn).__name__}")
+        return value
+
+
+GTxn = _GTxn()

algopy_testing/models/itxn.py

@@ -0,0 +1,85 @@
+import typing
+from collections.abc import Callable
+
+
+class _ITxn:
+    def __getattr__(self, name: str) -> Callable[[], typing.Any]:
+        from algopy_testing.context import get_test_context
+
+        context = get_test_context()
+        if not context:
+            raise ValueError(
+                "Test context is not initialized! Use `with algopy_testing_context()` to access "
+                "the context manager."
+            )
+        if not context._inner_transaction_groups:
+            raise ValueError(
+                "No inner transaction found in the context! Use `with algopy_testing_context()` "
+                "to access the context manager."
+            )
+        last_itxn_group = context._inner_transaction_groups[-1]
+
+        if not last_itxn_group:
+            raise ValueError("No inner transaction found in the testing context!")
+
+        last_itxn = last_itxn_group[-1]
+
+        value = getattr(last_itxn, name)
+        if value is None:
+            raise ValueError(f"'{name}' is not defined for {type(last_itxn).__name__} ")
+        # mimic the static functions on ITxn with a lambda
+        return lambda: value
+
+
+ITxn = _ITxn()
+
+
+class _ITxnCreate:
+    @classmethod
+    def begin(cls) -> None:
+        from algopy_testing.context import get_test_context
+
+        context = get_test_context()
+        context._constructing_inner_transaction_group = []
+
+    @classmethod
+    def next(cls) -> None:
+        from algopy_testing.context import get_test_context
+
+        context = get_test_context()
+        if context._constructing_inner_transaction:
+            context._constructing_inner_transaction_group.append(
+                context._constructing_inner_transaction
+            )
+            context._constructing_inner_transaction = None
+
+    @classmethod
+    def submit(cls) -> None:
+        from algopy_testing.context import get_test_context
+
+        context = get_test_context()
+        if context._constructing_inner_transaction:
+            context._constructing_inner_transaction_group.append(
+                context._constructing_inner_transaction
+            )
+            context._constructing_inner_transaction = None
+            context._inner_transaction_groups.append(context._constructing_inner_transaction_group)
+            context._constructing_inner_transaction_group = []
+
+    def __setattr__(self, name: str, value: typing.Any) -> None:
+        if name.startswith("set_"):
+            field = name[4:]  # Remove 'set_' prefix
+            self._set_field(field, value)
+        else:
+            super().__setattr__(name, value)
+
+    def _set_field(self, field: str, value: typing.Any) -> None:
+        from algopy_testing.context import get_test_context
+
+        context = get_test_context()
+        if not context._constructing_inner_transaction:
+            raise ValueError("No active inner transaction. Call ITxnCreate.begin() first.")
+        setattr(context._constructing_inner_transaction, field, value)
+
+
+ITxnCreate = _ITxnCreate()

algopy_testing/models/logicsig.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import typing
+from functools import wraps
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Callable
+
+    import algopy
+
+
+class LogicSig:
+    """A logic signature"""
+
+    def __init__(self, func: Callable[[], bool | algopy.UInt64], name: str | None = None):
+        self.func = func
+        self.name = name or func.__name__
+
+
+@typing.overload
+def logicsig(sub: Callable[[], bool | algopy.UInt64], /) -> LogicSig: ...
+
+
+@typing.overload
+def logicsig(*, name: str) -> Callable[[Callable[[], bool | algopy.UInt64]], LogicSig]: ...
+
+
+def logicsig(
+    sub: Callable[[], bool | algopy.UInt64] | None = None, *, name: str | None = None
+) -> algopy.LogicSig | Callable[[Callable[[], bool | algopy.UInt64]], LogicSig]:
+    """Decorator to indicate a function is a logic signature"""
+    import algopy
+
+    def decorator(func: Callable[[], bool | algopy.UInt64]) -> algopy.LogicSig:
+        @wraps(func)
+        def wrapper() -> bool | algopy.UInt64:
+            return func()
+
+        return algopy.LogicSig(wrapper, name=name)
+
+    if sub is None:
+        return decorator
+    else:
+        return decorator(sub)

algopy_testing/models/template_variable.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import typing
+
+_T = typing.TypeVar("_T")
+
+
+class TemplateVarGeneric:
+    def __getitem__(self, type_: type[_T]) -> typing.Callable[[str], typing.Any]:
+        from algopy_testing.context import get_test_context
+
+        context = get_test_context()
+
+        def create_template_var(variable_name: str) -> typing.Any:
+            if variable_name not in context._template_vars:
+                raise ValueError(f"Template variable {variable_name} not found in test context!")
+            return context._template_vars[variable_name]
+
+        return create_template_var
+
+
+TemplateVar: TemplateVarGeneric = TemplateVarGeneric()
+"""Template variables can be used to represent a placeholder for a deploy-time provided value."""

algopy_testing/models/transactions.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import typing
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import algopy
+
+
+class _TransactionCoreFields(TypedDict, total=False):
+    sender: algopy.Account
+    fee: algopy.UInt64
+    first_valid: algopy.UInt64
+    first_valid_time: algopy.UInt64
+    last_valid: algopy.UInt64
+    note: algopy.Bytes
+    lease: algopy.Bytes
+    txn_id: algopy.Bytes
+    rekey_to: algopy.Account
+
+
+class _TransactionBaseFields(_TransactionCoreFields, total=False):
+    type: algopy.TransactionType
+    type_bytes: algopy.Bytes
+
+
+class _AssetTransferBaseFields(TypedDict, total=False):
+    xfer_asset: algopy.Asset
+    asset_amount: algopy.UInt64
+    asset_sender: algopy.Account
+    asset_receiver: algopy.Account
+    asset_close_to: algopy.Account
+
+
+class _PaymentBaseFields(TypedDict, total=False):
+    receiver: algopy.Account
+    amount: algopy.UInt64
+    close_remainder_to: algopy.Account
+
+
+class _AssetFreezeBaseFields(TypedDict, total=False):
+    freeze_asset: algopy.Asset
+    freeze_account: algopy.Account
+    frozen: bool
+
+
+class _AssetConfigBaseFields(TypedDict, total=False):
+    config_asset: algopy.Asset
+    total: algopy.UInt64
+    decimals: algopy.UInt64
+    default_frozen: bool
+    unit_name: algopy.Bytes
+    asset_name: algopy.Bytes
+    url: algopy.Bytes
+    metadata_hash: algopy.Bytes
+    manager: algopy.Account
+    reserve: algopy.Account
+    freeze: algopy.Account
+    clawback: algopy.Account
+
+
+class _ApplicationCallCoreFields(TypedDict, total=False):
+    app_id: algopy.Application
+    on_completion: algopy.OnCompleteAction
+    num_app_args: algopy.UInt64
+    num_accounts: algopy.UInt64
+    approval_program: algopy.Bytes
+    clear_state_program: algopy.Bytes
+    num_assets: algopy.UInt64
+    num_apps: algopy.UInt64
+    global_num_uint: algopy.UInt64
+    global_num_bytes: algopy.UInt64
+    local_num_uint: algopy.UInt64
+    local_num_bytes: algopy.UInt64
+    extra_program_pages: algopy.UInt64
+    last_log: algopy.Bytes
+    num_approval_program_pages: algopy.UInt64
+    num_clear_state_program_pages: algopy.UInt64
+
+
+class _ApplicationCallBaseFields(_ApplicationCallCoreFields, total=False):
+    app_args: typing.Callable[[algopy.UInt64 | int], algopy.Bytes]
+    accounts: typing.Callable[[algopy.UInt64 | int], algopy.Account]
+    assets: typing.Callable[[algopy.UInt64 | int], algopy.Asset]
+    apps: typing.Callable[[algopy.UInt64 | int], algopy.Application]
+    approval_program_pages: typing.Callable[[algopy.UInt64 | int], algopy.Bytes]
+    clear_state_program_pages: typing.Callable[[algopy.UInt64 | int], algopy.Bytes]
+
+
+class _ApplicationCallFields(_TransactionBaseFields, _ApplicationCallCoreFields, total=False):
+    pass
+
+
+class _KeyRegistrationBaseFields(TypedDict, total=False):
+    vote_key: algopy.Bytes
+    selection_key: algopy.Bytes
+    vote_first: algopy.UInt64
+    vote_last: algopy.UInt64
+    vote_key_dilution: algopy.UInt64
+    non_participation: bool
+    state_proof_key: algopy.Bytes
+
+
+class _TransactionFields(
+    _TransactionBaseFields,
+    _PaymentBaseFields,
+    _KeyRegistrationBaseFields,
+    _AssetConfigBaseFields,
+    _AssetTransferBaseFields,
+    _AssetFreezeBaseFields,
+    _ApplicationCallBaseFields,
+    total=False,
+):
+    pass
+
+
+class AssetTransferFields(_TransactionBaseFields, _AssetTransferBaseFields, total=False):
+    pass
+
+
+class PaymentFields(_TransactionBaseFields, _PaymentBaseFields, total=False):
+    pass
+
+
+class AssetFreezeFields(_TransactionBaseFields, _AssetFreezeBaseFields, total=False):
+    pass
+
+
+class AssetConfigFields(_TransactionBaseFields, _AssetConfigBaseFields, total=False):
+    pass
+
+
+class ApplicationCallFields(_TransactionBaseFields, _ApplicationCallBaseFields, total=False):
+    pass
+
+
+class KeyRegistrationFields(_TransactionBaseFields, _KeyRegistrationBaseFields, total=False):
+    pass
+
+
+__all__ = [
+    "ApplicationCallFields",
+    "AssetConfigFields",
+    "AssetFreezeFields",
+    "AssetTransferFields",
+    "KeyRegistrationFields",
+    "PaymentFields",
+    "_ApplicationCallBaseFields",
+    "_ApplicationCallFields",
+    "_AssetConfigBaseFields",
+    "_AssetFreezeBaseFields",
+    "_AssetTransferBaseFields",
+    "_KeyRegistrationBaseFields",
+    "_PaymentBaseFields",
+    "_TransactionBaseFields",
+    "_TransactionCoreFields",
+    "_TransactionFields",
+]

algopy_testing/models/txn.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import typing
+from typing import TYPE_CHECKING, TypedDict, TypeVar
+
+if TYPE_CHECKING:
+    import algopy
+
+
+T = TypeVar("T")
+
+
+class TxnFields(TypedDict, total=False):
+    sender: algopy.Account
+    fee: algopy.UInt64
+    first_valid: algopy.UInt64
+    first_valid_time: algopy.UInt64
+    last_valid: algopy.UInt64
+    note: algopy.Bytes
+    lease: algopy.Bytes
+    receiver: algopy.Account
+    amount: algopy.UInt64
+    close_remainder_to: algopy.Account
+    vote_pk: algopy.Bytes
+    selection_pk: algopy.Bytes
+    vote_first: algopy.UInt64
+    vote_last: algopy.UInt64
+    vote_key_dilution: algopy.UInt64
+    type: algopy.Bytes
+    type_enum: algopy.UInt64
+    xfer_asset: algopy.Asset
+    asset_amount: algopy.UInt64
+    asset_sender: algopy.Account
+    asset_receiver: algopy.Account
+    asset_close_to: algopy.Account
+    group_index: algopy.UInt64
+    tx_id: algopy.Bytes
+    application_id: algopy.Application
+    on_completion: algopy.UInt64
+    num_app_args: algopy.UInt64
+    num_accounts: algopy.UInt64
+    approval_program: algopy.Bytes
+    clear_state_program: algopy.Bytes
+    rekey_to: algopy.Account
+    config_asset: algopy.Asset
+    config_asset_total: algopy.UInt64
+    config_asset_decimals: algopy.UInt64
+    config_asset_default_frozen: bool
+    config_asset_unit_name: algopy.Bytes
+    config_asset_name: algopy.Bytes
+    config_asset_url: algopy.Bytes
+    config_asset_metadata_hash: algopy.Bytes
+    config_asset_manager: algopy.Account
+    config_asset_reserve: algopy.Account
+    config_asset_freeze: algopy.Account
+    config_asset_clawback: algopy.Account
+    freeze_asset: algopy.Asset
+    freeze_asset_account: algopy.Account
+    freeze_asset_frozen: bool
+    num_assets: algopy.UInt64
+    num_applications: algopy.UInt64
+    global_num_uint: algopy.UInt64
+    global_num_byte_slice: algopy.UInt64
+    local_num_uint: algopy.UInt64
+    local_num_byte_slice: algopy.UInt64
+    extra_program_pages: algopy.UInt64
+    nonparticipation: bool
+    num_logs: algopy.UInt64
+    created_asset_id: algopy.Asset
+    created_application_id: algopy.Application
+    last_log: algopy.Bytes
+    state_proof_pk: algopy.Bytes
+    num_approval_program_pages: algopy.UInt64
+    num_clear_state_program_pages: algopy.UInt64
+    application_args: tuple[algopy.Bytes, ...]
+    accounts: tuple[algopy.Account, ...]
+    assets: tuple[algopy.Asset, ...]
+    applications: tuple[algopy.Application, ...]
+    logs: tuple[algopy.Bytes, ...]
+    approval_program_pages: tuple[algopy.Bytes, ...]
+    clear_state_program_pages: tuple[algopy.Bytes, ...]
+
+
+class _Txn:
+    def _map_fields(self, name: str) -> str:
+        field_mapping = {"type": "type_bytes", "type_enum": "type", "application_args": "app_args"}
+        return field_mapping.get(name, name)
+
+    def __getattr__(self, name: str) -> typing.Any:
+        from algopy_testing.context import get_test_context
+
+        context = get_test_context()
+        if not context:
+            raise ValueError(
+                "Test context is not initialized! Use `with algopy_testing_context()` to access "
+                "the context manager."
+            )
+        active_txn = context.get_active_transaction()
+        if name in context._txn_fields and context._txn_fields[name] is not None:  # type: ignore[literal-required]
+            return context._txn_fields[name]  # type: ignore[literal-required]
+        elif active_txn:
+            if context._active_transaction_index is not None and name == "group_index":
+                return context._active_transaction_index
+            return getattr(active_txn, self._map_fields(name))
+        else:
+            raise AttributeError(
+                f"'Txn' object has no value set for attribute named '{name}'. "
+                f"Use `context.patch_txn_fields({name}=your_value)` to set the value "
+                "in your test setup."
+            )
+
+
+Txn = _Txn()

algopy_testing/models/unsigned_builtins.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import typing
+
+from algopy_testing.utils import as_int64
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Reversible
+
+    import algopy
+
+
+class urange:  # noqa: N801
+    _value: range
+
+    def __init__(self, *args: int | algopy.UInt64) -> None:
+        self._value = range(*[as_int64(arg) for arg in args])
+
+    def __iter__(self) -> Iterator[algopy.UInt64]:
+        import algopy
+
+        return map(algopy.UInt64, self._value)
+
+    def __reversed__(self) -> Iterator[algopy.UInt64]:
+        import algopy
+
+        return map(algopy.UInt64, reversed(self._value))
+
+
+_T = typing.TypeVar("_T")
+
+
+def uenumerate(iterable: Iterable[_T]) -> Reversible[tuple[algopy.UInt64, _T]]:
+    import algopy
+
+    return [(algopy.UInt64(i), v) for i, v in enumerate(iterable)]