algorand-python-testing 0.1.0__py3-none-any.whl

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/utils.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import enum
+import functools
+import secrets
+from typing import TYPE_CHECKING
+
+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"))

algorand_python_testing-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.3
+Name: algorand-python-testing
+Version: 0.1.0
+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
+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: coincurve>=19.0.1
+Requires-Dist: ecdsa>=0.17.0
+Requires-Dist: pycryptodomex<4,>=3.6.0
+Requires-Dist: pynacl<2,>=1.4.0
+Requires-Dist: algorand-python>=1,<1.2.0
+Description-Content-Type: text/markdown
+
+# Algorand Python Testing framework
+
+Test your Algorand Python smart contracts using your favorite python testing tools.
+
+## Contributing
+
+We welcome contributions to this project! Read the [contributing guide](CONTRIBUTING.md) to get started.

algorand_python_testing-0.1.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+algopy/__init__.py,sha256=l4bTRdKBn9a1WnMtTTvpWYdm-FN_YdBZldEUWcIEBL8,792
+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=MbIdz1mOyIpo_6smkfnT2BtHSZSm6TlVyLUxONLnyBQ,1018
+algopy_testing/arc4.py,sha256=DJpZkHNkjGk23aReT_jzkd0U-RDlX3zoJ_MDnZOCRMM,41578
+algopy_testing/constants.py,sha256=_LIk53HoJ_jRNMGMpU7hgd5WZEmz-G7OzwnTjGCpdwk,559
+algopy_testing/context.py,sha256=oLZZ9vhWWkoEpeVD8JJb51IRLrCvF7_zYdkY1oXeYxE,24936
+algopy_testing/enums.py,sha256=Vm2XG2-C2NpfMf8Pml908PydGOBWYawlu6P0N4nDX-g,565
+algopy_testing/gtxn.py,sha256=90nZpNaYjeG7hJN0uCPZQ3_XkJRphlP_vXdtNt5VSrs,7119
+algopy_testing/itxn.py,sha256=rDcUGleCiVkttv1k_0Cs03skbGZH_VnFE-1pNPjqgj8,11310
+algopy_testing/op.py,sha256=OuZGLGumh66B3YZGpl6dJByf6WKRp6HFyZ3wsmMEUB8,18317
+algopy_testing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+algopy_testing/utils.py,sha256=7Ril5VA_kGN3RrnnCjCb3HYeVV8T9bNxLm6pFL8uNMc,4795
+algopy_testing/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+algopy_testing/decorators/abimethod.py,sha256=G1NzHSOb30LnorgtSdNqf1k7mFiSUGarJuYSOQIUoSE,4995
+algopy_testing/decorators/subroutine.py,sha256=7bQt-RBdqmbzosMTIllBh1KCEDUSyZwNSxXc-1guflw,192
+algopy_testing/models/__init__.py,sha256=dAUnsLdcIAKlsIp7CvIlOx3Xu9IRf6pm4pnTDTjIXX8,655
+algopy_testing/models/account.py,sha256=vR_furAVjNGkT1x8vJ8BQeOuCyjg3Cwc1pIGUkwX-R0,4215
+algopy_testing/models/application.py,sha256=H5WuY0gAfoTQE9glutAhKTfQs-iC4Nm7czmOpv-OqiQ,2205
+algopy_testing/models/asset.py,sha256=qsvC7vGDKTH_PHqybc0SAgzPLAjPgzgwK0aDliUxoLk,3471
+algopy_testing/models/contract.py,sha256=_jnw6FSiTQFsJlpqiqzLiH6_ct77cJk2dQs1MBO1IRw,1955
+algopy_testing/models/global_values.py,sha256=Hz6Vv2-Mc5I_Om5KsUHVP2nQVmBKDNgwZFlNTrDdyJw,2045
+algopy_testing/models/gtxn.py,sha256=nVsqmhnvRA4av2W2KRA7z5CXbrWOfpb2Mq-mifiXJnQ,1418
+algopy_testing/models/itxn.py,sha256=MItNb6vMsXKxHctR-1_vb5m4vv16iflQu8sz-nR__5Y,1159
+algopy_testing/models/transactions.py,sha256=_vMHFX8Nk6JYWOs3A-KkCjLfM8rsWM8BDAXuv_pZV7w,4313
+algopy_testing/models/txn.py,sha256=ZSx_NKMwXaxqu4fUbwjD0r9Bktbnx8T8jLIlEwzg__4,3767
+algopy_testing/models/unsigned_builtins.py,sha256=kXg1ylxwgTjpzzUnOQUK6I_kjlEvQzQ9MB6gWOd1PLo,261
+algopy_testing/primitives/__init__.py,sha256=qwhRtTef1hp9d8OAcwkhKhGc-NuEhaNxUoTlLzJFXk0,260
+algopy_testing/primitives/biguint.py,sha256=Ggnh5XwgCIFIb33Nwh1jvA9Kyn8nGBdk5cbFI41AS8M,5137
+algopy_testing/primitives/bytes.py,sha256=3XEYGmo0fkSDcVOqU2f4E9BxJgYfpVJTynM5XeZzvgs,5633
+algopy_testing/primitives/string.py,sha256=D3_QXXbHyrEbVjXIZ6L7Oo-kfKEbbOCAW461-UPnFuk,2127
+algopy_testing/primitives/uint64.py,sha256=kteVN31IfNXAB-Ny8qgEq0ZaoxzgZ9GzQwQWZCFKwGE,7046
+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
+algorand_python_testing-0.1.0.dist-info/METADATA,sha256=I_qIAhhc679Y_E5R2OdVzeOQNjAjldHWYWGWiTxfgDU,1193
+algorand_python_testing-0.1.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+algorand_python_testing-0.1.0.dist-info/RECORD,,

algorand_python_testing-0.1.0.dist-info/WHEEL

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