🔧 refactor(tests): remove unnecessary parentheses in assert statements for better readability and consistency with Python's idiomatic style

Author: superstructor

tests/intergration/__init__.py

@@ -1 +0,0 @@
-

tests/intergration/test_account_api.py

@@ -3,40 +3,43 @@
 
 """
 
-import pytest
 import secrets
 
+import pytest
+
 from convex_api import (
     API,
-    KeyPair,
+    KeyPair
 )
 from tests.types import KeyPairInfo
 
 TEST_ACCOUNT_NAME = 'test.convex-api'
 
+
 @pytest.fixture
 def account_name():
     return f'{TEST_ACCOUNT_NAME}-{secrets.token_hex(8)}'
 
+
 def test_account_api_create_account(convex_url: str):
 
     convex = API(convex_url)
     key_pair = KeyPair()
     result = convex.create_account(key_pair)
-    assert(result)
+    assert result
 
 
 def test_account_api_multi_create_account(convex_url: str):
     convex = API(convex_url)
     key_pair = KeyPair()
     account_1 = convex.create_account(key_pair)
-    assert(account_1)
+    assert account_1
     account_2 = convex.create_account(key_pair)
-    assert(account_2)
+    assert account_2
 
-    assert(account_1.public_key == account_1.public_key)
-    assert(account_1.public_key == account_2.public_key)
-    assert(account_1.address != account_2.address)
+    assert account_1.public_key == account_1.public_key
+    assert account_1.public_key == account_2.public_key
+    assert account_1.address != account_2.address
 
 
 def test_account_name(convex_url: str, test_key_pair_info: KeyPairInfo, account_name: str):
@@ -48,19 +51,19 @@ def test_account_name(convex_url: str, test_key_pair_info: KeyPairInfo, account_
         account = convex.create_account(import_key_pair)
         convex.topup_account(account)
         account = convex.register_account_name(account_name, account)
-    assert(account is not None)
-    assert(account.address)
-    assert(account.name)
-    assert(account.name == account_name)
-    assert(convex.resolve_account_name(account_name) == account.address)
+    assert account is not None
+    assert account.address
+    assert account.name
+    assert account.name == account_name
+    assert convex.resolve_account_name(account_name) == account.address
 
 
 def test_account_setup_account(convex_url: str, test_key_pair_info: KeyPairInfo, account_name: str):
     convex = API(convex_url)
     import_key_pair = KeyPair.import_from_bytes(test_key_pair_info['private_bytes'])
     account = convex.setup_account(account_name, import_key_pair)
-    assert(account is not None)
-    assert(account.address)
-    assert(account.name)
-    assert(account.name == account_name)
-    assert(convex.resolve_account_name(account_name) == account.address)
+    assert account is not None
+    assert account.address
+    assert account.name
+    assert account.name == account_name
+    assert convex.resolve_account_name(account_name) == account.address

tests/intergration/test_api.py

@@ -3,15 +3,14 @@
     Test Convex api
 
 """
-import pytest
 import secrets
 
+import pytest
+
 from convex_api.account import Account
 from convex_api.api import API
+from convex_api.exceptions import ConvexRequestError
 from convex_api.key_pair import KeyPair
-from convex_api.exceptions import (
-    ConvexRequestError
-)
 
 TEST_FUNDING_AMOUNT = 8888888
 
@@ -20,27 +19,29 @@ def test_convex_api_request_funds(convex_url: str, test_account: Account):
     convex = API(convex_url)
     amount = secrets.randbelow(100) + 1
     request_amount = convex.request_funds(amount, test_account)
-    assert(request_amount == amount)
+    assert request_amount == amount
+
 
 def test_convex_api_topup_account(convex_url: str):
     convex = API(convex_url)
     key_pair = KeyPair()
     account = convex.create_account(key_pair)
     topup_amount = TEST_FUNDING_AMOUNT
     amount = convex.topup_account(account, topup_amount)
-    assert(amount >= topup_amount)
+    assert amount >= topup_amount
 
     account = convex.create_account(key_pair)
     amount = convex.topup_account(account)
-    assert(amount >= 0)
+    assert amount >= 0
+
 
 def test_convex_get_account_info(convex_url: str, test_account: Account):
     convex = API(convex_url)
     info = convex.get_account_info(test_account)
-    assert(info)
-    assert(info.type == 'user')
-    assert(info.balance > 0)
-    assert(info.sequence >= 0)
+    assert info
+    assert info.type == 'user'
+    assert info.balance > 0
+    assert info.sequence >= 0
 
     with pytest.raises(ConvexRequestError, match='INCORRECT'):
         info = convex.get_account_info(pow(2, 100))
@@ -51,42 +52,42 @@ def test_convex_get_account_info(convex_url: str, test_account: Account):
     key_pair = KeyPair()
     account = convex.create_account(key_pair)
     request_amount = convex.request_funds(TEST_FUNDING_AMOUNT, account)
-    assert(request_amount == TEST_FUNDING_AMOUNT)
+    assert request_amount == TEST_FUNDING_AMOUNT
     info = convex.get_account_info(account)
-    assert(info)
-    assert(info.balance == TEST_FUNDING_AMOUNT)
+    assert info
+    assert info.balance == TEST_FUNDING_AMOUNT
+
 
 def test_convex_account_name_registry(convex_url: str, test_account: Account, test_key_pair: KeyPair):
     account_name = f'test.convex-api.{secrets.token_hex(4)}'
     convex = API(convex_url)
 
     address = convex.resolve_account_name(account_name)
-    assert(not address)
+    assert not address
 
     account = convex.load_account(account_name, test_key_pair)
-    assert(not account)
-
+    assert not account
 
     register_account = convex.register_account_name(account_name, test_account)
-    assert(register_account.address == test_account.address)
+    assert register_account.address == test_account.address
 
-    assert(convex.resolve_account_name(account_name) == test_account.address)
+    assert convex.resolve_account_name(account_name) == test_account.address
 
     new_account = convex.create_account(test_key_pair)
     register_account = convex.register_account_name(account_name, new_account, test_account)
 
-    assert(register_account.address == new_account.address)
-    assert(convex.resolve_account_name(account_name) == new_account.address)
+    assert register_account.address == new_account.address
+    assert convex.resolve_account_name(account_name) == new_account.address
 
     # clear the cache in the registry
     convex.registry.clear()
-    assert(convex.resolve_account_name(account_name) == new_account.address)
+    assert convex.resolve_account_name(account_name) == new_account.address
 
 
 def test_convex_resolve_name(convex_url: str):
     convex = API(convex_url)
     address = convex.resolve_name('convex.trust')
-    assert(address)
+    assert address
 
 
 def test_convex_transfer_account(convex_url: str, test_account: Account):
@@ -97,60 +98,64 @@ def test_convex_transfer_account(convex_url: str, test_account: Account):
     account_1 = convex.create_account(key_pair)
     convex.topup_account(account_1)
     result = convex.send('(map inc [1 2 3 4 5])', account_1)
-    assert(result is not None)
+    assert result is not None
     assert 'value' in result.model_dump()
-    assert(result.value == [2, 3, 4, 5, 6])
+    assert result.value == [2, 3, 4, 5, 6]
 
     # transfer the new account_1 to use the same keys as the test_account
     account_1_change = convex.transfer_account(test_account, account_1)
-    assert(account_1_change)
+    assert account_1_change
     # public key should be the same as the test_account
-    assert(account_1_change.key_pair.is_equal(test_account.key_pair))
+    assert account_1_change.key_pair.is_equal(test_account.key_pair)
     # adress still the same
-    assert(account_1_change.address == account_1.address )
+    assert account_1_change.address == account_1.address
 
     # test out new key
     result = convex.send('(map inc [1 2 3 4 5])', account_1_change)
-    assert(result is not None)
+    assert result is not None
     assert 'value' in result.model_dump()
-    assert(result.value == [2, 3, 4, 5, 6])
+    assert result.value == [2, 3, 4, 5, 6]
 
 
 def test_convex_api_send_basic_lisp(convex_url: str, test_account: Account):
     convex = API(convex_url)
     request_amount = convex.request_funds(TEST_FUNDING_AMOUNT, test_account)
-    assert(request_amount == TEST_FUNDING_AMOUNT)
+    assert request_amount == TEST_FUNDING_AMOUNT
     result = convex.send('(map inc [1 2 3 4 5])', test_account)
-    assert(result is not None)
+    assert result is not None
     assert 'value' in result.model_dump()
-    assert(result.value == [2, 3, 4, 5, 6])
+    assert result.value == [2, 3, 4, 5, 6]
+
 
 def test_convex_api_get_balance_no_funds(convex_url: str):
     convex = API(convex_url)
     key_pair = KeyPair()
     account = convex.create_account(key_pair)
     new_balance = convex.get_balance(account)
-    assert(new_balance == 0)
+    assert new_balance == 0
+
 
 def test_convex_api_get_balance_small_funds(convex_url: str, test_account: Account):
     convex = API(convex_url)
     key_pair = KeyPair()
     account = convex.create_account(key_pair)
     amount = 100
     request_amount = convex.request_funds(amount, account)
-    assert(request_amount == amount)
+    assert request_amount == amount
     new_balance = convex.get_balance(account)
-    assert(new_balance == amount)
+    assert new_balance == amount
+
 
 def test_convex_api_get_balance_new_account(convex_url: str):
     convex = API(convex_url)
     key_pair = KeyPair()
     account = convex.create_account(key_pair)
     amount = TEST_FUNDING_AMOUNT
     request_amount = convex.request_funds(amount, account)
-    assert(request_amount == amount)
+    assert request_amount == amount
     new_balance = convex.get_balance(account)
-    assert(new_balance == TEST_FUNDING_AMOUNT)
+    assert new_balance == TEST_FUNDING_AMOUNT
+
 
 def test_convex_api_call(convex_url: str):
 
@@ -181,58 +186,61 @@ def test_convex_api_call(convex_url: str):
     account = convex.create_account(key_pair)
     amount = TEST_FUNDING_AMOUNT
     request_amount = convex.request_funds(amount, account)
-    assert(request_amount == amount)
+    assert request_amount == amount
     result = convex.send(deploy_storage, account)
-    assert(result is not None)
+    assert result is not None
     contract_address = Account.to_address(result.value)
-    assert(contract_address)
+    assert contract_address
     test_number = secrets.randbelow(1000)
     call_set_result = convex.send(f'(call storage-example(set {test_number}))', account)
-    assert(call_set_result is not None)
-    assert(call_set_result.value == test_number)
+    assert call_set_result is not None
+    assert call_set_result.value == test_number
     call_get_result = convex.query('(call storage-example(get))', account)
-    assert(call_get_result is not None)
-    assert(call_get_result.value == test_number)
+    assert call_get_result is not None
+    assert call_get_result.value == test_number
 
     # now api calls using language scrypt
     """
     convex = API(convex_url, API.LANGUAGE_SCRYPT)
     test_number = secrets.randbelow(1000)
     call_set_result = convex.send(f'call storage_example set({test_number})', account)
-    assert(call_set_result['value'] == test_number)
+    assert call_set_result['value'] == test_number
 
     call_get_result = convex.query('call storage_example get()', account)
-    assert(call_get_result['value'] == test_number)
+    assert call_get_result['value'] == test_number
 
     call_get_result = convex.query(f'call {contract_address} get()', account)
-    assert(call_get_result['value'] == test_number)
+    assert call_get_result['value'] == test_number
 
     with pytest.raises(ConvexRequestError, match='400'):
         call_set_result = convex.send(f'call {contract_address}.set({test_number})', account)
 
     address = convex.get_address('storage_example', account)
-    assert(address == contract_address)
+    assert address == contract_address
     """
+
+
 def test_convex_api_transfer(convex_url: str):
     convex = API(convex_url)
     key_pair = KeyPair()
     account_from = convex.create_account(key_pair)
     account_to = convex.create_account(key_pair)
     amount = TEST_FUNDING_AMOUNT
     request_amount = convex.request_funds(amount, account_from)
-    assert(request_amount == amount)
+    assert request_amount == amount
 
     transfer_amount = int(amount / 2)
     result = convex.transfer(account_to, transfer_amount, account_from)
-    assert(result)
-    assert(result == transfer_amount)
-    #balance_from = convex.get_balance(account_from)
+    assert result
+    assert result == transfer_amount
+    # balance_from = convex.get_balance(account_from)
     balance_to = convex.get_balance(account_to)
-    assert(balance_to == transfer_amount)
+    assert balance_to == transfer_amount
+
 
 def test_convex_api_query_lisp(convex_url: str, test_account: Account):
     convex = API(convex_url)
     result = convex.query(f'(address {test_account.address})', test_account)
-    assert(result is not None)
+    assert result is not None
     # return value is the address as a checksum
-    assert(Account.to_address(result.value) == test_account.address)
+    assert Account.to_address(result.value) == test_account.address