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

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

@@ -1,4 +1,16 @@
 # CHANGELOG
+## v1.2.0-beta.3 (2025-12-08)
+
+### Features
+
+* add stage and submit_staged functions to support submitting dynamic number of inner transactions in a group ([`84ad031`](https://github.com/algorandfoundation/algorand-python-testing/commit/84ad03166442dadc10c7c1fe70e4cd07a63600cc))
+
+## v1.2.0-beta.2 (2025-12-08)
+
+### Features
+
+* add algopy.public alias for algopy.arc4.abimethod decorator ([`32a2787`](https://github.com/algorandfoundation/algorand-python-testing/commit/32a27877a30f03e5330aa1bdb7a4fadbea543529))
+
 ## v1.2.0-beta.1 (2025-12-05)
 
 ### Features

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

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

@@ -40,6 +40,7 @@ See which `algorand-python` stubs are implemented by the `algorand-python-testin
 | algopy.ensure_budget                        | Emulated            |
 | algopy.log                                  | Emulated            |
 | algopy.logicsig                             | Emulated            |
+| algopy.public                               | Emulated            |
 | algopy.size_of                              | Emulated            |
 | algopy.subroutine                           | Native              |
 | algopy.uenumerate                           | Native              |
@@ -95,6 +96,7 @@ See which `algorand-python` stubs are implemented by the `algorand-python-testin
 | algopy.itxn.KeyRegistrationInnerTransaction | Emulated            |
 | algopy.itxn.Payment                         | Emulated            |
 | algopy.itxn.PaymentInnerTransaction         | Emulated            |
+| algopy.itxn.submit_staged                   | Emulated            |
 | algopy.itxn.submit_txns                     | Emulated            |
 | algopy.op.Base64                            | Native              |
 | algopy.op.EC                                | Native              |

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/docs/index.md

@@ -62,7 +62,7 @@ class VotingContract(algopy.ARC4Contract):
         )
         self.voted = algopy.LocalState(algopy.UInt64, key="voted", description="Tracks if an account has voted")
 
-    @arc4.abimethod
+    @algopy.public
     def set_topic(self, topic: arc4.String) -> None:
         self.topic.value = topic.bytes
 
@@ -79,7 +79,7 @@ class VotingContract(algopy.ARC4Contract):
         self.voted[algopy.Txn.sender] = algopy.UInt64(1)
         return arc4.Bool(True)
 
-    @arc4.abimethod(readonly=True)
+    @algopy.public(readonly=True)
     def get_votes(self) -> arc4.UInt64:
         return arc4.UInt64(self.votes.value)
 
@@ -141,9 +141,9 @@ This example demonstrates key aspects of testing with `algorand-python-testing`
 1. ARC4 Contract Features:
 
     - Use of `algopy.ARC4Contract` as the base class for the contract.
-    - ABI methods defined using the `@arc4.abimethod` decorator.
+    - ABI methods defined using the `@arc4.abimethod`, or its alias `@algopy.public`, decorator.
     - Use of ARC4-specific types like `arc4.String`, `arc4.Bool`, and `arc4.UInt64`.
-    - Readonly method annotation with `@arc4.abimethod(readonly=True)`.
+    - Readonly method annotation with `@arc4.abimethod(readonly=True)` or `@algopy.public(readonly=True)` .
 
 2. Testing ARC4 Contracts:
 

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/docs/testing-guide/concepts.md

@@ -61,5 +61,5 @@ For a full list of all public `algopy` types and their corresponding implementat
 
 ## Data Validation
 
-Algorand Python and the puya compiler have functionality to perform validation of transaction inputs via the `--validate-abi-args`, `--validate-abi-return` CLI arguments, `arc4.abimethod(validate_encoding=...)` decorator and `.validate()` methods. 
-The Algorand Python Testing library does *NOT* implement this validation behaviour, as you should test invalid inputs using an integrated test against a real Algorand network. 
+Algorand Python and the puya compiler have functionality to perform validation of transaction inputs via the `--validate-abi-args`, `--validate-abi-return` CLI arguments, `arc4.abimethod(validate_encoding=...)` decorator (or its alias, `algopy.public`) and `.validate()` methods.
+The Algorand Python Testing library does _NOT_ implement this validation behaviour, as you should test invalid inputs using an integrated test against a real Algorand network.

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/docs/testing-guide/contract-testing.md

@@ -1,6 +1,6 @@
 # Smart Contract Testing
 
-This guide provides an overview of how to test smart contracts using the Algorand Python SDK (`algopy`). It covers the basics of testing `ARC4Contract` and `Contract` classes, focusing on the `abimethod` and `baremethod` decorators.
+This guide provides an overview of how to test smart contracts using the Algorand Python SDK (`algopy`). It covers the basics of testing `ARC4Contract` and `Contract` classes, focusing on the `baremethod`, `abimethod` and `public` (an alias of `abimethod`) decorators.
 
 ![](https://mermaid.ink/img/pako:eNqVkrFugzAQhl_Fujnp1ImhEiJrJNREWeoOV9sNVsFG9iEVBd69R5w0JE2llsk2n7-7_-AAymsDGewDtpXYrqQT_GyKFwl5vfcBnRZlT5V3IjYYSCjvKKAiCa-JzXfrObyzgTqsxRpVZZ25YOX2nnRrIomCneZzpszLkllktu0f8ratrUKyjFsXCZ1K2gTH7i01_8dGUjOT_55YeLdUFVr3zRunf5b6R5hZoFnBq9cX72_Br_Cj8bl4vJCHaVucvowYxHk5Xg_sfPkY6SbbphDL5dMgQZu29n0U5DMJwzTVGyApySKZKFSNMXKVxPJYYAGNCQ1azX_VYboqgSrTcAcZLzWGDwnSjcxhR37TOwUZhc4sIPhuX0H2jnXkXddqrrCyyKNpTqfjF5m74B8?type=png)
 
@@ -24,7 +24,7 @@ context = ctx_manager.__enter__()
 
 Subclasses of `algopy.ARC4Contract` are **required** to be instantiated with an active test context. As part of instantiation, the test context will automatically create a matching `algopy.Application` object instance.
 
-Within the class implementation, methods decorated with `algopy.arc4.abimethod` and `algopy.arc4.baremethod` will automatically assemble an `algopy.gtxn.ApplicationCallTransaction` to emulate the AVM application call. This behaviour can be overridden by setting the transaction group manually as part of test setup; this is done via implicit invocation of the `algopy_testing.context.any_application()` _value generator_ (refer to the [API](../api.md) for more details).
+Within the class implementation, methods decorated with `algopy.arc4.abimethod` (or its alias, `algopy.public`) and `algopy.arc4.baremethod` will automatically assemble an `algopy.gtxn.ApplicationCallTransaction` to emulate the AVM application call. This behaviour can be overridden by setting the transaction group manually as part of test setup; this is done via implicit invocation of the `algopy_testing.context.any_application()` _value generator_ (refer to the [API](../api.md) for more details).
 
 ```{testcode}
 class SimpleVotingContract(algopy.ARC4Contract):
@@ -42,14 +42,14 @@ class SimpleVotingContract(algopy.ARC4Contract):
         self.topic.value = initial_topic
         self.votes.value = algopy.UInt64(0)
 
-    @algopy.arc4.abimethod
+    @algopy.public
     def vote(self) -> algopy.UInt64:
         assert self.voted[algopy.Txn.sender] == algopy.UInt64(0), "Account has already voted"
         self.votes.value += algopy.UInt64(1)
         self.voted[algopy.Txn.sender] = algopy.UInt64(1)
         return self.votes.value
 
-    @algopy.arc4.abimethod(readonly=True)
+    @algopy.public(readonly=True)
     def get_votes(self) -> algopy.UInt64:
         return self.votes.value
 
@@ -74,7 +74,7 @@ assert contract.topic.value == initial_topic
 assert contract.votes.value == algopy.UInt64(0)
 
 # Act - Vote
-# The method `.vote()` is decorated with `algopy.arc4.abimethod`, which means it will assemble a transaction to emulate the AVM application call
+# The method `.vote()` is decorated with `algopy.public`, an alias of `algopy.arc4.abimethod`, which means it will assemble a transaction to emulate the AVM application call
 result = contract.vote()
 
 # Assert - you can access the corresponding auto generated application call transaction via test context

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/docs/testing-guide/subroutines.md

@@ -18,6 +18,8 @@ context = ctx_manager.__enter__()
 
 The `@algopy.subroutine` decorator exposes contract methods for isolated testing within the Algorand Python Testing framework. This enables focused validation of core business logic without the overhead of full application deployment and execution.
 
+`@algopy.subroutine` decorator is optional for the methods in a contract which are not callable externally.
+
 ## Usage
 
 1. Decorate internal methods with `@algopy.subroutine`:
@@ -26,7 +28,7 @@ The `@algopy.subroutine` decorator exposes contract methods for isolated testing
 from algopy import subroutine, UInt64
 
 class MyContract:
-    @subroutine
+    @subroutine # optional
     def calculate_value(self, input: UInt64) -> UInt64:
         return input * UInt64(2)
 ```

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/docs/testing-guide/transactions.md

@@ -143,7 +143,7 @@ When testing smart contracts, to stay consistent with AVM, the framework _does n
 
 ```{testcode}
 class MyContract(algopy.ARC4Contract):
-    @algopy.arc4.abimethod
+    @algopy.public
     def pay_via_itxn(self, asset: algopy.Asset) -> None:
         algopy.itxn.Payment(
             receiver=algopy.Txn.sender,
@@ -180,7 +180,7 @@ first_payment_txn = first_itxn_group.payment(0)
 
 In this example, we define a contract method `pay_via_itxn` that creates and submits an inner payment transaction. The test context automatically captures and stores the inner transactions submitted by the contract method.
 
-Note that we don't need to wrap the execution in a `create_group` context manager because the method is decorated with `@algopy.arc4.abimethod`, which automatically creates a transaction group for the method. The `create_group` context manager is only needed when you want to create more complex transaction groups or patch transaction fields for various transaction-related opcodes in AVM.
+Note that we don't need to wrap the execution in a `create_group` context manager because the method is decorated with `@algopy.public`, an alias of `@algopy.arc4.abimethod`, which automatically creates a transaction group for the method. The `create_group` context manager is only needed when you want to create more complex transaction groups or patch transaction fields for various transaction-related opcodes in AVM.
 
 To access the submitted inner transactions:
 
@@ -190,6 +190,75 @@ To access the submitted inner transactions:
 
 These methods provide type validation and will raise an error if the requested transaction type doesn't match the actual type of the inner transaction.
 
+### Submitting a group with dynamic number of inner transactions
+
+`algorand-python` supports composing inner transaction groups with a dynamic number of transactions. To use this feature, call the `.stage()` method on inner transaction classes to queue transactions, then call `algopy.itxn.submit_staged()` to submit all staged transactions as a group.
+
+The following example demonstrates how to test this functionality using the `algorand-python-testing` package.
+
+```{testcode}
+from algopy import Application, ARC4Contract, Array, Global, arc4, gtxn, itxn, TransactionType, Txn, UInt64, urange
+
+class DynamicItxnGroup(ARC4Contract):
+    @arc4.abimethod
+    def distribute(
+        self, addresses: Array[arc4.Address], funds: gtxn.PaymentTransaction, verifier: Application
+    ) -> None:
+        assert funds.receiver == Global.current_application_address, "Funds must be sent to app"
+
+        assert addresses.length, "must provide some accounts"
+
+        share = funds.amount // addresses.length
+
+        itxn.Payment(amount=share, receiver=addresses[0].native).stage(begin_group=True)
+
+        for i in urange(1, addresses.length):
+            addr = addresses[i]
+            itxn.Payment(amount=share, receiver=addr.native).stage()
+
+        itxn.ApplicationCall(
+            app_id=verifier.id, app_args=(arc4.arc4_signature("verify()void"),)
+        ).stage()
+
+        itxn.AssetConfig(asset_name="abc").stage()
+
+        itxn.submit_staged()
+
+class VerifierContract(ARC4Contract):
+    @arc4.abimethod
+    def verify(self) -> None:
+        for i in urange(Txn.group_index):
+            txn = gtxn.Transaction(i)
+            assert txn.type == TransactionType.Payment, "Txn must be pay"
+
+
+# create contract instaces
+verifier = VerifierContract()
+dynamic_itxn_group = DynamicItxnGroup()
+
+# get application id for contract instances
+verifier_app = context.ledger.get_app(verifier)
+dynamic_itxn_group_app = context.ledger.get_app(dynamic_itxn_group)
+
+# create test accounts to distribute funds to and initial fund
+addresses = Array([arc4.Address(context.any.account()) for _ in range(3)])
+payment = context.any.txn.payment(
+    amount=UInt64(9),
+    receiver=dynamic_itxn_group_app.address,
+)
+
+# call contract method which creates inner transactions according to number of addresses passed in
+dynamic_itxn_group.distribute(addresses, payment, verifier_app)
+
+# get inner transaction group to assert the details
+itxns = context.txn.last_group.get_itxn_group(-1)
+assert len(itxns) == 5
+for i in range(3):
+    assert itxns.payment(i).amount == 3
+assert itxns.application_call(3).app_id == verifier_app
+assert itxns.asset_config(4).asset_name == b"abc"
+```
+
 ## References
 
 -   [API](../api.md) for more details on the test context manager and inner transactions related methods that perform implicit inner transaction type validation.

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/examples/marketplace/contract.py

@@ -9,7 +9,6 @@ from algopy import (
     gtxn,
     itxn,
     op,
-    subroutine,
 )
 from algopy.arc4 import abimethod
 
@@ -32,7 +31,6 @@ class DigitalMarketplace(ARC4Contract):
     def __init__(self) -> None:
         self.listings = BoxMap(ListingKey, ListingValue)
 
-    @subroutine
     def listings_box_mbr(self) -> UInt64:
         return (
             2_500
@@ -55,7 +53,6 @@ class DigitalMarketplace(ARC4Contract):
             * 400
         )
 
-    @subroutine
     def quantity_price(self, quantity: UInt64, price: UInt64, asset_decimals: UInt64) -> UInt64:
         amount_not_scaled_high, amount_not_scaled_low = op.mulw(price, quantity)
         scaling_factor_high, scaling_factor_low = op.expw(10, asset_decimals)

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/examples/proof_of_attendance/contract.py

@@ -8,12 +8,12 @@ class ProofOfAttendance(algopy.ARC4Contract):
         self.total_attendees = algopy.UInt64(0)
         self.box_map = algopy.BoxMap(algopy.Bytes, algopy.UInt64)
 
-    @algopy.arc4.abimethod(create="require")
+    @algopy.public(create="require")
     def init(self, max_attendees: algopy.UInt64) -> None:
         assert algopy.Txn.sender == algopy.Global.creator_address, "Only creator can initialize"
         self.max_attendees = max_attendees
 
-    @algopy.arc4.abimethod()
+    @algopy.public()
     def confirm_attendance(self) -> None:
         assert self.total_attendees < self.max_attendees, "Max attendees reached"
 
@@ -25,7 +25,7 @@ class ProofOfAttendance(algopy.ARC4Contract):
 
         algopy.op.Box.put(algopy.Txn.sender.bytes, algopy.op.itob(minted_asset.id))
 
-    @algopy.arc4.abimethod()
+    @algopy.public()
     def confirm_attendance_with_box(self) -> None:
         assert self.total_attendees < self.max_attendees, "Max attendees reached"
 
@@ -38,7 +38,7 @@ class ProofOfAttendance(algopy.ARC4Contract):
 
         box.value = minted_asset.id
 
-    @algopy.arc4.abimethod()
+    @algopy.public()
     def confirm_attendance_with_box_ref(self) -> None:
         assert self.total_attendees < self.max_attendees, "Max attendees reached"
 
@@ -51,7 +51,7 @@ class ProofOfAttendance(algopy.ARC4Contract):
 
         box_ref.value = algopy.op.itob(minted_asset.id)
 
-    @algopy.arc4.abimethod()
+    @algopy.public()
     def confirm_attendance_with_box_map(self) -> None:
         assert self.total_attendees < self.max_attendees, "Max attendees reached"
 
@@ -63,33 +63,33 @@ class ProofOfAttendance(algopy.ARC4Contract):
 
         self.box_map[algopy.Txn.sender.bytes] = minted_asset.id
 
-    @algopy.arc4.abimethod(readonly=True)
+    @algopy.public(readonly=True)
     def get_poa_id(self) -> algopy.UInt64:
         poa_id, exists = algopy.op.Box.get(algopy.Txn.sender.bytes)
         assert exists, "POA not found"
         return algopy.op.btoi(poa_id)
 
-    @algopy.arc4.abimethod(readonly=True)
+    @algopy.public(readonly=True)
     def get_poa_id_with_box(self) -> algopy.UInt64:
         box = algopy.Box(algopy.UInt64, key=algopy.Txn.sender.bytes)
         poa_id, exists = box.maybe()
         assert exists, "POA not found"
         return poa_id
 
-    @algopy.arc4.abimethod(readonly=True)
+    @algopy.public(readonly=True)
     def get_poa_id_with_box_ref(self) -> algopy.UInt64:
         box_ref = algopy.Box(algopy.Bytes, key=algopy.Txn.sender.bytes)
         poa_id, exists = box_ref.maybe()
         assert exists, "POA not found"
         return algopy.op.btoi(poa_id)
 
-    @algopy.arc4.abimethod(readonly=True)
+    @algopy.public(readonly=True)
     def get_poa_id_with_box_map(self) -> algopy.UInt64:
         poa_id, exists = self.box_map.maybe(algopy.Txn.sender.bytes)
         assert exists, "POA not found"
         return poa_id
 
-    @algopy.arc4.abimethod()
+    @algopy.public()
     def claim_poa(self, opt_in_txn: algopy.gtxn.AssetTransferTransaction) -> None:
         poa_id, exists = algopy.op.Box.get(algopy.Txn.sender.bytes)
         assert exists, "POA not found, attendance validation failed!"
@@ -108,7 +108,7 @@ class ProofOfAttendance(algopy.ARC4Contract):
             algopy.op.btoi(poa_id),
         )
 
-    @algopy.arc4.abimethod()
+    @algopy.public()
     def claim_poa_with_box(self, opt_in_txn: algopy.gtxn.AssetTransferTransaction) -> None:
         box = algopy.Box(algopy.UInt64, key=algopy.Txn.sender.bytes)
         poa_id, exists = box.maybe()
@@ -128,7 +128,7 @@ class ProofOfAttendance(algopy.ARC4Contract):
             poa_id,
         )
 
-    @algopy.arc4.abimethod()
+    @algopy.public()
     def claim_poa_with_box_ref(self, opt_in_txn: algopy.gtxn.AssetTransferTransaction) -> None:
         box_ref = algopy.Box(algopy.Bytes, key=algopy.Txn.sender.bytes)
         poa_id, exists = box_ref.maybe()
@@ -148,7 +148,7 @@ class ProofOfAttendance(algopy.ARC4Contract):
             algopy.op.btoi(poa_id),
         )
 
-    @algopy.arc4.abimethod()
+    @algopy.public()
     def claim_poa_with_box_map(self, opt_in_txn: algopy.gtxn.AssetTransferTransaction) -> None:
         poa_id, exists = self.box_map.maybe(algopy.Txn.sender.bytes)
         assert exists, "POA not found, attendance validation failed!"

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/examples/simple_voting/contract.py

@@ -8,7 +8,6 @@ from algopy import (
     Txn,
     UInt64,
     op,
-    subroutine,
 )
 
 VOTE_PRICE = 10_000
@@ -24,11 +23,9 @@ class VotingContract(Contract):
         )
         self.voted = LocalState(UInt64, key="voted", description="Tracks if an account has voted")
 
-    @subroutine
     def set_topic(self, topic: Bytes) -> None:
         self.topic.value = topic
 
-    @subroutine
     def vote(self, voter: Account) -> bool:
         assert op.Global.group_size == UInt64(2)
         assert op.GTxn.amount(1) == UInt64(VOTE_PRICE)
@@ -40,7 +37,6 @@ class VotingContract(Contract):
         self.voted[voter] = UInt64(1)
         return True
 
-    @subroutine
     def get_votes(self) -> UInt64:
         return self.votes.value
 

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

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

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

@@ -1,3 +1,4 @@
+# ruff: noqa: I001
 from _algopy_testing import arc4, gtxn, itxn
 from _algopy_testing.context import AlgopyTestContext
 from _algopy_testing.context_helpers.context_storage import algopy_testing_context
@@ -24,6 +25,9 @@ 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
 from _algopy_testing.value_generators.txn import TxnValueGenerator
+from _algopy_testing.decorators.arc4 import (
+    abimethod as public,
+)
 
 __all__ = [
     "ARC4Contract",
@@ -60,6 +64,7 @@ __all__ = [
     "gtxn",
     "itxn",
     "logicsig",
+    "public",
     "subroutine",
     "uenumerate",
     "urange",

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/src/_algopy_testing/context_helpers/txn_context.py

@@ -326,19 +326,19 @@ class TransactionGroup:
         except ValueError:
             raise ValueError("Transaction is not part of this group") from None
 
-    def _begin_itxn_group(self) -> None:
+    def _begin_itxn_group(self, itxn: InnerTransaction | None = None) -> None:
         if self._constructing_itxn_group:
             raise RuntimeError("itxn begin without itxn submit")
 
         if self.active_txn.on_completion == OnCompleteAction.ClearState:
             raise RuntimeError("Cannot begin inner transaction group in a clear state call")
 
-        self._constructing_itxn_group.append(InnerTransaction())
+        self._constructing_itxn_group.append(itxn or InnerTransaction())
 
-    def _append_itxn_group(self) -> None:
+    def _append_itxn_group(self, itxn: InnerTransaction | None = None) -> None:
         if not self._constructing_itxn_group:
             raise RuntimeError("itxn next without itxn begin")
-        self._constructing_itxn_group.append(InnerTransaction())
+        self._constructing_itxn_group.append(itxn or InnerTransaction())
 
     def _submit_itxn_group(self) -> None:
         if not self._constructing_itxn_group:

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/src/_algopy_testing/itxn.py

@@ -33,6 +33,7 @@ __all__ = [
     "KeyRegistrationInnerTransaction",
     "Payment",
     "PaymentInnerTransaction",
+    "submit_staged",
     "submit_txns",
 ]
 
@@ -113,6 +114,12 @@ class _BaseInnerTransactionFields(typing.Protocol[_TResult_co]):
         _narrow_covariant_types(fields)
         self.fields.update(fields)
 
+    def stage(self, *, begin_group: bool = False) -> None:
+        if begin_group:
+            lazy_context.active_group._begin_itxn_group(self)  # type: ignore[arg-type]
+        else:
+            lazy_context.active_group._append_itxn_group(self)  # type: ignore[arg-type]
+
     def submit(self) -> _TResult_co:
         result = _get_itxn_result(self)
         lazy_context.active_group._add_itxn_group([result])  # type: ignore[list-item]
@@ -170,6 +177,10 @@ def submit_txns(
     return results
 
 
+def submit_staged() -> None:
+    lazy_context.active_group._submit_itxn_group()
+
+
 def _get_itxn_result(
     itxn: _BaseInnerTransactionFields[_TResult_co],
 ) -> _BaseInnerTransactionResult:

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

@@ -1,3 +1,4 @@
+# ruff: noqa: I001
 from _algopy_testing.compiled import (
     CompiledContract,
     CompiledLogicSig,
@@ -33,6 +34,9 @@ from _algopy_testing.state import Box, BoxMap, BoxRef, GlobalState, LocalState
 from _algopy_testing.utilities import OpUpFeeSource, ensure_budget, log, size_of
 
 from . import arc4, gtxn, itxn, op
+from _algopy_testing.decorators.arc4 import (
+    abimethod as public,
+)
 
 __all__ = [
     "ARC4Contract",
@@ -76,6 +80,7 @@ __all__ = [
     "log",
     "logicsig",
     "op",
+    "public",
     "size_of",
     "subroutine",
     "uenumerate",

{algorand_python_testing-1.2.0b1 → algorand_python_testing-1.2.0b3}/tests/arc4/test_abi_call.py

@@ -4,12 +4,12 @@ from collections.abc import Generator
 import pytest
 from _algopy_testing import AlgopyTestContext, algopy_testing_context
 from _algopy_testing.itxn import ApplicationCallInnerTransaction
-from algopy import ARC4Contract, arc4
+from algopy import ARC4Contract, arc4, public
 from pytest_mock import MockerFixture
 
 
 class Logger(ARC4Contract):
-    @arc4.abimethod
+    @public
     def echo(self, value: arc4.String) -> arc4.String:
         return "echo: " + value