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

algopy_testing/state/global_state.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import typing
+from typing import cast, overload
+
+_T = typing.TypeVar("_T")
+
+
+class GlobalState(typing.Generic[_T]):
+    @overload
+    def __init__(
+        self,
+        type_: type[_T],
+        /,
+        *,
+        key: bytes | str = "",
+        description: str = "",
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        initial_value: _T,
+        /,
+        *,
+        key: bytes | str = "",
+        description: str = "",
+    ) -> None: ...
+
+    def __init__(
+        self,
+        type_or_value: type[_T] | _T,
+        /,
+        *,
+        key: bytes | str = "",
+        description: str = "",
+    ) -> None:
+        if isinstance(type_or_value, type):
+            self.type_ = type_or_value
+            self._value: _T | None = None
+        else:
+            self.type_ = type(type_or_value)
+            self._value = type_or_value
+
+        self.key = key
+        self.description = description
+
+    @property
+    def value(self) -> _T:
+        if self._value is None:
+            raise ValueError("Value is not set")
+        return self._value
+
+    @value.setter
+    def value(self, value: _T) -> None:
+        self._value = value
+
+    @value.deleter
+    def value(self) -> None:
+        self._value = None
+
+    def __bool__(self) -> bool:
+        return self._value is not None
+
+    def get(self, default: _T | None = None) -> _T:
+        if self._value is not None:
+            return self._value
+        if default is not None:
+            return default
+        return cast(_T, self.type_())
+
+    def maybe(self) -> tuple[_T | None, bool]:
+        return self._value, self._value is not None

algopy_testing/state/local_state.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import typing
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import algopy
+
+_T = typing.TypeVar("_T")
+
+
+class LocalState(typing.Generic[_T]):
+    def __init__(
+        self,
+        type_: type[_T],
+        /,
+        *,
+        key: bytes | str = "",
+        description: str = "",
+    ) -> None:
+        self.type_ = type_
+        self.key = key
+        self.description = description
+        self._state: dict[object, _T] = {}
+
+    def _validate_local_state_key(self, key: algopy.Account | algopy.UInt64 | int) -> None:
+        from algopy import Account, UInt64
+
+        if not isinstance(key, Account | UInt64 | int):
+            raise TypeError(f"Invalid key type {type(key)} for LocalState")
+
+    def __setitem__(self, key: algopy.Account | algopy.UInt64 | int, value: _T) -> None:
+        self._validate_local_state_key(key)
+        self._state[key] = value
+
+    def __getitem__(self, key: algopy.Account | algopy.UInt64 | int) -> _T:
+        self._validate_local_state_key(key)
+        return self._state[key]
+
+    def __delitem__(self, key: algopy.Account | algopy.UInt64 | int) -> None:
+        self._validate_local_state_key(key)
+        del self._state[key]
+
+    def __contains__(self, key: algopy.Account | algopy.UInt64 | int) -> bool:
+        self._validate_local_state_key(key)
+        return key in self._state
+
+    def get(self, key: algopy.Account | algopy.UInt64 | int, default: _T | None = None) -> _T:
+        self._validate_local_state_key(key)
+        return self._state.get(key, default if default is not None else self.type_())
+
+    def maybe(self, key: algopy.Account | algopy.UInt64 | int) -> tuple[object, bool]:
+        self._validate_local_state_key(key)
+        return self._state.get(key), key in self._state

algopy_testing/utilities/__init__.py

@@ -0,0 +1,3 @@
+from algopy_testing.utilities.budget import OpUpFeeSource, ensure_budget
+
+__all__ = ["OpUpFeeSource", "ensure_budget", "log"]

algopy_testing/utilities/budget.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from algopy_testing import UInt64
+
+
+class OpUpFeeSource(UInt64):
+    """Defines the source of fees for the OpUp utility."""
+
+    GroupCredit: OpUpFeeSource
+    AppAccount: OpUpFeeSource
+    Any: OpUpFeeSource
+
+
+OpUpFeeSource.GroupCredit = OpUpFeeSource(0)
+OpUpFeeSource.AppAccount = OpUpFeeSource(1)
+OpUpFeeSource.Any = OpUpFeeSource(2)
+
+
+def ensure_budget(
+    required_budget: UInt64 | int,  # noqa: ARG001
+    fee_source: OpUpFeeSource = OpUpFeeSource.GroupCredit,  # noqa: ARG001
+) -> None:
+    pass

algopy_testing/utilities/log.py

@@ -0,0 +1,55 @@
+from algopy_testing.primitives.bytes import Bytes
+from algopy_testing.primitives.uint64 import UInt64
+from algopy_testing.protocols import BytesBacked
+from algopy_testing.utils import int_to_bytes
+
+
+def log(  # noqa: C901, PLR0912
+    *args: UInt64 | Bytes | BytesBacked | str | bytes | int,
+    sep: Bytes | bytes | str = b"",
+) -> None:
+    """Concatenates and logs supplied args as a single bytes value.
+
+    UInt64 args are converted to bytes and each argument is separated by `sep`.
+    Literal `str` values will be encoded as UTF8.
+    """
+    import algopy
+
+    from algopy_testing.context import get_test_context
+
+    context = get_test_context()
+    logs: list[bytes] = []
+
+    for arg in args:
+        if isinstance(arg, UInt64):
+            logs.append(int_to_bytes(arg.value))
+        elif isinstance(arg, Bytes):
+            logs.append(arg.value)
+        elif isinstance(arg, str):
+            logs.append(arg.encode("utf8"))
+        elif isinstance(arg, bytes):
+            logs.append(arg)
+        elif isinstance(arg, int):
+            logs.append(int_to_bytes(arg))
+        else:
+            logs.append(arg.bytes.value)
+
+    separator = b""
+    if isinstance(sep, Bytes):
+        separator = sep.value
+    elif isinstance(sep, str):
+        separator = sep.encode("utf8")
+    else:
+        separator = sep
+
+    active_txn = context.get_active_transaction()
+    if not active_txn:
+        raise ValueError("Cannot emit events outside of application call context!")
+    if active_txn.type != algopy.TransactionType.ApplicationCall:
+        raise ValueError("Cannot emit events outside of application call context!")
+    if not active_txn.app_id:
+        raise ValueError("Cannot emit event: missing `app_id` in associated call transaction!")
+    context.add_application_logs(
+        app_id=active_txn.app_id(),
+        logs=separator.join(logs),
+    )

algopy_testing/utils.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import enum
+import functools
+import secrets
+import typing
+from types import UnionType
+from typing import TYPE_CHECKING, get_args
+
+import algosdk
+import algosdk.transaction
+
+from algopy_testing import arc4
+from algopy_testing.constants import MAX_BYTES_SIZE, MAX_UINT8, MAX_UINT16, MAX_UINT64, MAX_UINT512
+
+if TYPE_CHECKING:
+    import algopy
+
+
+def as_int(value: object, *, max: int | None) -> int:  # noqa: A002
+    """
+    Returns the underlying int value for any numeric type up to UInt512
+
+    Raises:
+        TypeError: If `value` is not a numeric type
+        ValueError: If not 0 <= `value` <= max
+    """
+
+    from algopy_testing.primitives.biguint import BigUInt
+    from algopy_testing.primitives.uint64 import UInt64
+
+    match value:
+        case int(int_value):
+            pass
+        case UInt64(value=int_value):
+            pass
+        case BigUInt(value=int_value):
+            pass
+        case arc4.UIntN():
+            int_value = value.native.value
+        case arc4.BigUIntN():
+            int_value = value.native.value
+        # TODO: add arc4 numerics
+        case _:
+            raise TypeError(f"value must be a numeric type, not {type(value).__name__!r}")
+    if int_value < 0:
+        raise ValueError(f"expected positive value, got {int_value}")
+    if max is not None and int_value > max:
+        raise ValueError(f"expected value <= {max}, got: {int_value}")
+    return int_value
+
+
+def as_int8(value: object) -> int:
+    return as_int(value, max=MAX_UINT8)
+
+
+def as_int16(value: object) -> int:
+    return as_int(value, max=MAX_UINT16)
+
+
+def as_int64(value: object) -> int:
+    return as_int(value, max=MAX_UINT64)
+
+
+def as_int512(value: object) -> int:
+    return as_int(value, max=MAX_UINT512)
+
+
+def as_bytes(value: object, *, max_size: int = MAX_BYTES_SIZE) -> bytes:
+    """
+    Returns the underlying bytes value for bytes or Bytes type up to 4096
+
+    Raises:
+        TypeError: If `value` is not a bytes type
+        ValueError: If not 0 <= `len(value)` <= max_size
+    """
+    from algopy_testing.primitives.bytes import Bytes
+
+    match value:
+        case bytes(bytes_value):
+            pass
+        case Bytes(value=bytes_value):
+            pass
+        case _:
+            raise TypeError(f"value must be a bytes or Bytes type, not {type(value).__name__!r}")
+    if len(bytes_value) > max_size:
+        raise ValueError(f"expected value length <= {max_size}, got: {len(bytes_value)}")
+    return bytes_value
+
+
+def as_string(value: object) -> str:
+    from algopy_testing.primitives.string import String
+
+    match value:
+        case str(string_value) | String(value=string_value):
+            return string_value
+        case arc4.String():
+            return value.native.value
+        case _:
+            raise TypeError(f"value must be a string or String type, not {type(value).__name__!r}")
+
+
+def int_to_bytes(x: int, pad_to: int | None = None) -> bytes:
+    result = x.to_bytes((x.bit_length() + 7) // 8, "big")
+    result = (
+        b"\x00" * (pad_to - len(result)) if pad_to is not None and len(result) < pad_to else b""
+    ) + result
+
+    return result
+
+
+def dummy_transaction_id() -> bytes:
+    private_key, address = algosdk.account.generate_account()
+
+    suggested_params = algosdk.transaction.SuggestedParams(fee=1000, first=0, last=1, gh="")
+    txn = algosdk.transaction.PaymentTxn(
+        sender=address,
+        receiver=address,
+        amt=1000,
+        sp=suggested_params,
+        note=secrets.token_bytes(8),
+    )
+
+    signed_txn = txn.sign(private_key)
+    txn_id = str(signed_txn.transaction.get_txid()).encode("utf-8")
+    return txn_id
+
+
+class _TransactionStrType(enum.StrEnum):
+    PAYMENT = algosdk.constants.PAYMENT_TXN
+    KEYREG = algosdk.constants.KEYREG_TXN
+    ASSETCONFIG = algosdk.constants.ASSETCONFIG_TXN
+    ASSETTRANSFER = algosdk.constants.ASSETTRANSFER_TXN
+    ASSETFREEZE = algosdk.constants.ASSETFREEZE_TXN
+    APPCALL = algosdk.constants.APPCALL_TXN
+
+
+@functools.cache
+def txn_type_to_bytes(txn_type: int) -> algopy.Bytes:
+    import algopy
+
+    match txn_type:
+        case algopy.TransactionType.Payment:
+            result = _TransactionStrType.PAYMENT
+        case algopy.TransactionType.KeyRegistration:
+            result = _TransactionStrType.KEYREG
+        case algopy.TransactionType.AssetConfig:
+            result = _TransactionStrType.ASSETCONFIG
+        case algopy.TransactionType.AssetTransfer:
+            result = _TransactionStrType.ASSETTRANSFER
+        case algopy.TransactionType.AssetFreeze:
+            result = _TransactionStrType.ASSETFREEZE
+        case algopy.TransactionType.ApplicationCall:
+            result = _TransactionStrType.APPCALL
+        case _:
+            raise ValueError(f"invalid transaction type: {txn_type}")
+
+    return algopy.Bytes(bytes(result, encoding="utf-8"))
+
+
+def is_instance(obj: object, class_or_tuple: type | UnionType) -> bool:
+    if isinstance(class_or_tuple, UnionType):
+        return any(is_instance(obj, arg) for arg in get_args(class_or_tuple))
+
+    if isinstance(obj, typing._ProtocolMeta):  # type: ignore[type-check, unused-ignore]
+        return (
+            f"{obj.__module__}.{obj.__name__}"
+            == f"{class_or_tuple.__module__}.{class_or_tuple.__name__}"  # type: ignore[union-attr, unused-ignore]
+        )
+
+    # Manual comparison by module and name
+    if (
+        hasattr(obj, "__module__")
+        and hasattr(obj, "__name__")
+        and (
+            obj.__module__,
+            obj.__name__,  # type: ignore[attr-defined, unused-ignore]
+        )
+        == (
+            class_or_tuple.__module__,
+            class_or_tuple.__name__,
+        )
+    ):
+        return True
+
+    return isinstance(obj, class_or_tuple)
+
+
+def abi_type_name_for_arg(  # noqa: PLR0912, C901, PLR0911
+    *, arg: object, is_return_type: bool = False
+) -> str:
+    """
+    Returns the ABI type name for the given argument. Especially convenient for use with
+    algosdk to generate method signatures
+    """
+    import algopy
+
+    if is_instance(arg, algopy.arc4.String | algopy.String | str):
+        return "string"
+    if is_instance(arg, algopy.arc4.Bool | bool):
+        return "bool"
+    if is_instance(arg, algopy.BigUInt):
+        return "uint512"
+    if is_instance(arg, algopy.UInt64):
+        return "uint64"
+    if isinstance(arg, int):
+        return "uint64" if arg <= MAX_UINT64 else "uint512"
+    if is_instance(arg, algopy.Bytes | bytes):
+        return "byte[]"
+    if is_instance(arg, algopy.arc4.Address):
+        return "address"
+    if is_instance(arg, algopy.Asset):
+        return "uint64" if is_return_type else "asset"
+    if is_instance(arg, algopy.Account):
+        return "uint64" if is_return_type else "account"
+    if is_instance(arg, algopy.Application):
+        return "uint64" if is_return_type else "application"
+    if is_instance(arg, algopy.arc4.UIntN):
+        return "uint" + str(arg._bit_size)  # type: ignore[attr-defined]
+    if is_instance(arg, algopy.arc4.BigUIntN):
+        return "uint" + str(arg._bit_size)  # type: ignore[attr-defined]
+    if is_instance(arg, algopy.arc4.UFixedNxM):
+        return f"ufixed{arg._n}x{arg._m}"  # type: ignore[attr-defined]
+    if is_instance(arg, algopy.arc4.BigUFixedNxM):
+        return f"ufixed{arg._n}x{arg._m}"  # type: ignore[attr-defined]
+    if is_instance(arg, algopy.arc4.StaticArray):
+        return f"{abi_type_name_for_arg(arg=arg[0],    # type: ignore[index]
+                                        is_return_type=is_return_type)}[{arg.length.value}]"  # type: ignore[attr-defined]
+    if is_instance(arg, algopy.arc4.DynamicArray):
+        return f"{abi_type_name_for_arg(arg=arg[0], # type: ignore[index]
+                                        is_return_type=is_return_type)}[]"
+    if isinstance(arg, tuple):
+        return f"({','.join(abi_type_name_for_arg(arg=a,
+                                                  is_return_type=is_return_type) for a in arg)})"
+    raise ValueError(f"Unsupported type {type(arg)}")
+
+
+def abi_return_type_annotation_for_arg(arg: object) -> str:
+    """
+    Returns the ABI type name for the given argument. Especially convenient for use with
+    algosdk to generate method signatures
+    """
+
+    try:
+        return abi_type_name_for_arg(arg=arg, is_return_type=True)
+    except ValueError:
+        if arg is None:
+            return "void"
+        raise

algorand_python_testing-0.0.0b1.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.3
+Name: algorand-python-testing
+Version: 0.0.0b1
+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
+Project-URL: Source, https://github.com/algorandfoundation/puya/tree/main/algopy_testing
+Author-email: Algorand Foundation <contact@algorand.foundation>
+License-Expression: AGPL-3.0-or-later
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.12
+Requires-Dist: algorand-python>=1.2
+Requires-Dist: coincurve>=19.0.1
+Requires-Dist: ecdsa>=0.17.0
+Requires-Dist: pycryptodomex<4,>=3.6.0
+Requires-Dist: pynacl<2,>=1.4.0
+Description-Content-Type: text/markdown
+
+<div align="center">
+<a href="https://github.com/algorandfoundation/algorand-python-testing"><img src="https://bafybeiaibjaf6zy6hvef2rrysaacsfsyb3hw4qqtgn657gw7k5tdzqdxzi.ipfs.nftstorage.link/" width=60%></a>
+</div>
+
+<p align="center">
+    <a target="_blank" href="https://algorandfoundation.github.io/algorand-python-testing/"><img src="https://img.shields.io/badge/docs-repository-74dfdc?logo=github&style=flat.svg" /></a>
+    <a target="_blank" href="https://developer.algorand.org/algokit/"><img src="https://img.shields.io/badge/learn-AlgoKit-74dfdc?logo=algorand&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algorand-python-testing"><img src="https://img.shields.io/github/stars/algorandfoundation/algorand-python-testing?color=74dfdc&logo=star&style=flat" /></a>
+    <a target="_blank" href="https://developer.algorand.org/algokit/"><img  src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fgithub.com%2Falgorandfoundation%2Falgorand-python-testing&countColor=%2374dfdc&style=flat" /></a>
+</p>
+
+---
+
+Algorand Python Testing is a companion package to [Algorand Python](https://github.com/algorandfoundation/puya) that enables efficient unit testing of Algorand Python smart contracts in an offline environment. It emulates key AVM behaviors without requiring a network connection, offering fast and reliable testing capabilities with a familiar Pythonic interface.
+
+[Documentation](https://algorandfoundation.github.io/algopy_testing/index.html) | [Algorand Python Documentation](https://algorandfoundation.github.io/puya/)
+
+## Quick start
+
+The easiest way to use Algorand Python Testing is to instantiate a template with AlgoKit via `algokit init -t python`. This will give you a full development environment with testing capabilities built-in.
+
+Alternatively, if you want to start from scratch:
+
+1. Ensure you have Python 3.12+
+2. Install [AlgoKit CLI](https://github.com/algorandfoundation/algokit-cli?tab=readme-ov-file#install)
+3. Install Algorand Python Testing into your project:
+    ```bash
+    pip install algopy-testing-python
+    ```
+4. Create a test file (e.g., `test_contract.py`):
+
+    ```python
+    from algopy_testing import algopy_testing_context
+    from your_contract import YourContract
+
+    def test_your_contract():
+    with algopy_testing_context() as ctx:
+    contract = YourContract() # Your test code here
+    ```
+
+5. Run your tests using your preferred Python testing framework (e.g., pytest, unittest)
+
+For more detailed information, check out the [full documentation](https://algorandfoundation.github.io/algopy_testing).
+
+## Features
+
+-   Offline testing environment simulating core AVM functionality
+-   Compatible with popular Python testing frameworks
+-   Supports testing of ARC4 contracts, smart signatures, and more
+-   Provides tools for mocking blockchain state and transactions
+
+## Examples
+
+For detailed examples showcasing various testing scenarios, refer to the [examples section](https://algorandfoundation.github.io/algopy_testing/examples.html) in the documentation.
+
+## Contributing
+
+We welcome contributions to this project! Please read our [contributing guide](CONTRIBUTING.md) to get started.

algorand_python_testing-0.0.0b1.dist-info/RECORD

@@ -0,0 +1,52 @@
+algopy/__init__.py,sha256=nd5hpdHpkfb5srMM6vHKfbOmEIxTutr4Dh0b7wwFq8Y,1143
+algopy/arc4.py,sha256=zE-cwwmeEBA0m22QiHIujeY0S5rdyf3gDqTyGgROAqI,48
+algopy/gtxn.py,sha256=tS2waKIr3g79T1xcmE2iVcvu524xANsR8awXduUVoT0,48
+algopy/itxn.py,sha256=gXida1ee8xMfRufZ24G4xPGGSe26Iwm9nqfHpQCxbpE,48
+algopy/op.py,sha256=JmF0QiVmqF1Oqhj9VypCl7ef-r2r-dHPI0hxIS3LQD8,46
+algopy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+algopy_testing/__init__.py,sha256=x7WpDet7utqy6M9MdE5OJeKLqNd1uAIPg_U2ZpDOenI,1150
+algopy_testing/arc4.py,sha256=3rCZGKs4-mH3SymHOrp190edGS9MV_v3L5oP_5_GBsA,52015
+algopy_testing/constants.py,sha256=L1-Vod3_k6NAmeHJ9d8qIIovSMlakudvd4VeR6BjPeo,733
+algopy_testing/context.py,sha256=TswTYyLMw1_novoEnoLoIIGrkN-c2xBCWoWFW7AOvs8,39371
+algopy_testing/enums.py,sha256=MJE7g_5wiI94a5oAaEdPGGaO7QS1wm5GgZlYtADwB1U,690
+algopy_testing/gtxn.py,sha256=ul1iBYt8Kwc9Xob_pWVwa6dj9ueQ0iIz2DHkC72Aga4,7954
+algopy_testing/itxn.py,sha256=lLz6dPBwTSvU5zmuKPQd0LkCLG1VJN2Q8Dmb6HRNb3s,23363
+algopy_testing/op.py,sha256=e_VY3pvgUuW_y64yolzzuxeN2Gpg4XkDcJM5fNK-iOg,33046
+algopy_testing/protocols.py,sha256=fPvuYAWKVVYM8oZE9hJtmRKW24Ba8VSzrBGz-7mDnIw,448
+algopy_testing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+algopy_testing/utils.py,sha256=PkDkHPAKJxyq6Jc0kWSVhF9MtIyNZmNv-hY2bPtwQ40,8393
+algopy_testing/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+algopy_testing/decorators/abimethod.py,sha256=8pRNP8EEExCkBk9i3mQukRrMngL6FnViJQKqWQjET1E,6756
+algopy_testing/decorators/baremethod.py,sha256=g-HJl49g5q5T40QHXLNZnVKob4XtGaPcWWX_F3Z7HKY,2324
+algopy_testing/decorators/subroutine.py,sha256=7bQt-RBdqmbzosMTIllBh1KCEDUSyZwNSxXc-1guflw,192
+algopy_testing/models/__init__.py,sha256=yQdq6-32r3NfVZWn-n4ILdLOiFDf8oxrKfyHRQPnv-I,923
+algopy_testing/models/account.py,sha256=vR_furAVjNGkT1x8vJ8BQeOuCyjg3Cwc1pIGUkwX-R0,4215
+algopy_testing/models/application.py,sha256=leMvgKkYt7Kct4ayUwkL7rQy65mpqp52oGnuoNO-1xA,2203
+algopy_testing/models/asset.py,sha256=qsvC7vGDKTH_PHqybc0SAgzPLAjPgzgwK0aDliUxoLk,3471
+algopy_testing/models/block.py,sha256=JwzoQ3Z7EIvOaSjbMlzQTQ7DztYejw43rQeRptolADs,876
+algopy_testing/models/box.py,sha256=CJrj9v0SwoJztyMVbe0Xu9ZHsAhWUdurAXjWo9lped8,5548
+algopy_testing/models/contract.py,sha256=9TwDC-5Ncxor2wn4_EVQ8ku6RpRkTNDTeuU64RKAmP0,2307
+algopy_testing/models/gitxn.py,sha256=MEWkVoK81Hoqz6Bb7uFAuGCZTb_G5lH9Vl1Dx_2nO7w,1594
+algopy_testing/models/global_values.py,sha256=cT5JKbcSY2_VenF6Pn3BkSj_iaV2D5o4uJZYyKXs2xQ,2215
+algopy_testing/models/gtxn.py,sha256=RJCwFyJvIbxwbF27RpWJaS04x7ZACKr1IPP3iXRS6Rk,1993
+algopy_testing/models/itxn.py,sha256=sgN4wvzolwYmdDJC-4hh6PXDWSBU6-FCjm4tuLIb0Y4,2995
+algopy_testing/models/logicsig.py,sha256=5l_7EL2_bVKZ_myc07La2G2_H8aYZF--Hd0tFMic2t0,1151
+algopy_testing/models/template_variable.py,sha256=FbyP9JniPasbgqYtPRfSOF2u6LWkc45suRSmTfURi5g,759
+algopy_testing/models/transactions.py,sha256=QATadTBJIaHERWuhXOsXEeSjVq-9QyHjJSAQrLOz5pc,4313
+algopy_testing/models/txn.py,sha256=chTwHOVpy9elV4ZVTIzVXS_JKTmc1OF6vhmzdyXEC_A,3912
+algopy_testing/models/unsigned_builtins.py,sha256=-6zoPjn1MTh0wzacsMhhLhAEy4DWdWq7TVFtHWP-QZA,826
+algopy_testing/primitives/__init__.py,sha256=xERIGR6lbEN-cPTtR5eH0yeJIawvjg2XQnmIeiwICKQ,260
+algopy_testing/primitives/biguint.py,sha256=Ss_wE9DCqweydiOFTQ3nCm4xZVTciD4b9qkFF0OVrNw,5199
+algopy_testing/primitives/bytes.py,sha256=TI-M5hA4NNTdiNwZg_70EH08VFHOW0f9Wm7RwVeCItk,5634
+algopy_testing/primitives/string.py,sha256=7eWrbFxu74nQ7ZdDg6GVsZ73VF_p24os7SnIoXKZuFk,2189
+algopy_testing/primitives/uint64.py,sha256=-vQHLYza-K7Y_Pms-49pQQ44B78CNLEYBb6X6Ny-G6c,7110
+algopy_testing/state/__init__.py,sha256=uRFuGSn7RMnhjVKWWdHnVtPNhNfTlQIoQaDPbcmkr3U,155
+algopy_testing/state/global_state.py,sha256=1eJRY9SYzOdj_dnNUqF_vghh0t9Q6N1B1MzLX0hKPxU,1662
+algopy_testing/state/local_state.py,sha256=7m98XD5Afbn72yvgw9Q_VLAEhObLBv_5trp11ZkGwuE,1788
+algopy_testing/utilities/__init__.py,sha256=y43zYxwO37xO9CodAENU9y5p6DBVrkDOHnoZZO77nxc,126
+algopy_testing/utilities/budget.py,sha256=P1pOKWCyya4wsqAwKgvp7y0p97hn2Kr2qFVRKm-sJZo,540
+algopy_testing/utilities/log.py,sha256=5MDJY8Oh_COt5OLZXWqkvAJk2qdfBpfSGIpidV-HJ4k,1870
+algorand_python_testing-0.0.0b1.dist-info/METADATA,sha256=zZpOXQVULRPTrkvGyeFCowcvmdZvIQkncTZEwLGz5-E,4172
+algorand_python_testing-0.0.0b1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+algorand_python_testing-0.0.0b1.dist-info/licenses/LICENSE,sha256=jRyAzzkz3HPr-knS8XWyDY8CyuU-L4RtydPP8uGWsUw,657
+algorand_python_testing-0.0.0b1.dist-info/RECORD,,

algorand_python_testing-0.0.0b1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any

algorand_python_testing-0.0.0b1.dist-info/licenses/LICENSE

@@ -0,0 +1,14 @@
+Copyright (C) 2024 Algorand Foundation
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.