🔧 refactor: replace Union type hints with the new Python 3.10 syntax using '|'

🔧 refactor: add __future__ import annotations for forward references

Author: superstructor

convex_api/account.py

@@ -4,16 +4,16 @@
 
 
 """
+from __future__ import annotations
 
 import re
-from typing import Union
 from convex_api.key_pair import KeyPair
 
 
 class Account:
 
     @staticmethod
-    def is_address(text: Union[int, str]) -> bool:
+    def is_address(text: int | str) -> bool:
         """
         Returns True if the text value is a valid address.
 
@@ -25,7 +25,7 @@ def is_address(text: Union[int, str]) -> bool:
         return Account.to_address(text) >= 0
 
     @staticmethod
-    def to_address(value: Union['Account', int, str]) -> int:
+    def to_address(value: Account | int | str) -> int:
         """
         Convert address text with possible leading '#' to an integer address value.
 
@@ -47,7 +47,7 @@ def to_address(value: Union['Account', int, str]) -> int:
                 raise ValueError(f'Invalid address {value}')
             return address
 
-    def __init__(self, key_pair: KeyPair, address: Union['Account', int, str], name: Union[str, None] = None):
+    def __init__(self, key_pair: KeyPair, address: Account | int | str, name: str | None = None):
         """
 
         Create a new account with a private key KeyPair.
@@ -133,7 +133,7 @@ def address(self) -> int:
         return self._address
 
     @address.setter
-    def address(self, value: Union['Account', int, str]) -> None:
+    def address(self, value: Account | int | str) -> None:
         """
 
         Sets the network address of this account
@@ -154,7 +154,7 @@ def address(self, value: Union['Account', int, str]) -> None:
         self._address = Account.to_address(value)
 
     @property
-    def name(self) -> Union[str, None]:
+    def name(self) -> str | None:
         return self._name
 
     @name.setter

convex_api/api.py

@@ -3,17 +3,18 @@
     Convex API
 
 """
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Dict
 
 import logging
 import re
 import secrets
 import time
-from typing import (
-    Any,
-    Dict,
-    Union,
-    cast
-)
+from typing import cast
 from urllib.parse import urljoin
 
 import requests
@@ -101,7 +102,7 @@ def create_account(self, key_pair: KeyPair, sequence_retry_count: int = 20) -> A
 
         return account
 
-    def load_account(self, name: str, key_pair: KeyPair) -> Union[Account, None]:
+    def load_account(self, name: str, key_pair: KeyPair) -> Account | None:
         """
 
         Load an account using the correct name. If successful return the :class:`.Account` object with the address set.
@@ -130,7 +131,7 @@ def load_account(self, name: str, key_pair: KeyPair) -> Union[Account, None]:
             new_account = Account(key_pair, address, name=name)
             return new_account
 
-    def setup_account(self, name: str, key_pair: KeyPair, register_account: Union[Account, None] = None) -> Union[Account, None]:
+    def setup_account(self, name: str, key_pair: KeyPair, register_account: Account | None = None) -> Account | None:
         """
 
         Convenience method to create or load an account based on the account name.
@@ -174,8 +175,8 @@ def setup_account(self, name: str, key_pair: KeyPair, register_account: Union[Ac
     def register_account_name(
         self,
         name: str,
-        address_account: Union[Account, int, str],
-        account: Union[Account, None] = None
+        address_account: Account | int | str,
+        account: Account | None = None
     ) -> Account:
         """
 
@@ -287,7 +288,7 @@ def send(self, transaction: str, account: Account, sequence_retry_count: int = 2
     def query(
         self,
         transaction: str,
-        address_account: Union[int, str, Account]
+        address_account: int | str | Account
     ):
         """
 
@@ -398,7 +399,7 @@ def topup_account(
             retry_count -= 1
         return transfer_amount
 
-    def get_address(self, function_name: str, address_account: Union[Account, int, str]):
+    def get_address(self, function_name: str, address_account: Account | int | str):
         """
 
         Query the network for a contract ( function ) address. The contract must have been deployed
@@ -425,7 +426,7 @@ def get_address(self, function_name: str, address_account: Union[Account, int, s
         result = self.query(line, address_account)
         return Account.to_address(result.value)
 
-    def get_balance(self, address_account: Union[Account, int, str], account_from: Union[Account, int, str, None] = None):
+    def get_balance(self, address_account: Account | int | str, account_from: Account | int | str | None = None):
         """
 
         Get a balance of an account.
@@ -473,7 +474,7 @@ def get_balance(self, address_account: Union[Account, int, str], account_from: U
             value = cast(int, result.value)
         return value
 
-    def transfer(self, to_address_account: Union[Account, int, str], amount: Union[int, float], account: Account):
+    def transfer(self, to_address_account: Account | int | str, amount: int | float, account: Account):
         """
 
         Transfer funds from on account to another.
@@ -513,7 +514,7 @@ def transfer(self, to_address_account: Union[Account, int, str], amount: Union[i
             return result.value
         return 0
 
-    def transfer_account(self, from_account: Union[Account, int, str], to_account: Union[Account, int, str]):
+    def transfer_account(self, from_account: Account | int | str, to_account: Account | int | str):
         """
 
         **WARNING**
@@ -564,7 +565,7 @@ def transfer_account(self, from_account: Union[Account, int, str], to_account: U
         if result is not None and from_account.key_pair.is_equal(result.value):
             return Account(from_account.key_pair, to_account.address, to_account.name)
 
-    def get_account_info(self, address_account: Union[Account, int, str]) -> AccountDetailsResponse:
+    def get_account_info(self, address_account: Account | int | str) -> AccountDetailsResponse:
         """
 
         Get account information. This will only work with an account that has a balance or has had some transactions
@@ -605,7 +606,7 @@ def get_account_info(self, address_account: Union[Account, int, str]) -> Account
 
         return result
 
-    def resolve_account_name(self, name: str) -> Union[int, None]:
+    def resolve_account_name(self, name: str) -> int | None:
         """
         Resolves an account name to an address.
         :param string name Name of the account to resolve.
@@ -618,7 +619,7 @@ def resolve_account_name(self, name: str) -> Union[int, None]:
         """
         return self._registry.resolve_address(f'account.{name}')
 
-    def resolve_name(self, name: str) -> Union[int, None]:
+    def resolve_name(self, name: str) -> int | None:
         """
         Resolves any Convex Name Services to an address.
         :param string name Name of the the CNS Service.
@@ -641,11 +642,11 @@ def load_contract(self, name: str):
     def _post(
         self,
         url: str,
-        data: Union[CreateAccountRequest, FaucetRequest, QueryRequest, PrepareTransactionRequest, SubmitTransactionRequest],
+        data: CreateAccountRequest | FaucetRequest | QueryRequest | PrepareTransactionRequest | SubmitTransactionRequest,
         sequence_retry_count: int = 20
-    ) -> Union[Dict[str, Any], None]:
+    ) -> Dict[str, Any] | None:
         max_sleep_time_seconds = 1
-        result: Union[Dict[str, Any], None] = None
+        result: Dict[str, Any] | None = None
         while sequence_retry_count >= 0:
             response = requests.post(url, data=data.model_dump_json())
             if response.status_code == 200:
@@ -668,8 +669,8 @@ def _post(
     def _transaction_prepare(
         self,
         transaction: str,
-        address: Union[Account, int, str],
-        sequence_number: Union[int, None] = None
+        address: Account | int | str,
+        sequence_number: int | None = None
     ) -> PrepareTransactionResponse:
         """
         A transaction requires its hash to be digitally signed by the executing account prior to submission.
@@ -703,15 +704,15 @@ def _transaction_prepare(
 
     def _transaction_submit(
         self,
-        address: Union[Account, int, str],
+        address: Account | int | str,
         public_key: str,
         hash_data: str,
         signed_data: str
     ) -> SubmitTransactionResponse:
         """
         Submit a transaction to the Convex network.
 
-        :param Union[Account, int, str] address: :class:`.Account` object or address of the executing account.
+        :param Account | int, str address: :class:`.Account` object or address of the executing account.
         :param str public_key: Public key of the executing account.
         :param str hash_data: Hash of the transaction to be submitted.
         :param str signed_data: Ed25519 signature of the transaction hash.
@@ -733,7 +734,7 @@ def _transaction_submit(
 
     def _transaction_query(
         self,
-        address: Union[Account, int, str],
+        address: Account | int | str,
         transaction: str
     ):
         """

convex_api/contract.py

@@ -6,7 +6,6 @@
 """
 
 import re
-from typing import Union
 from convex_api.account import Account
 from convex_api.api import API
 
@@ -25,9 +24,9 @@ def __init__(self, convex: API):
 
     def load(
         self,
-        name: Union[str, None] = None,
-        address: Union[Account, int, str, None] = None,
-        owner_address: Union[Account, int, str, None] = None
+        name: str | None = None,
+        address: Account | int | str | None = None,
+        owner_address: Account | int | str | None = None
     ):
         """
 
@@ -62,10 +61,10 @@ def load(
     def deploy(
         self,
         account: Account,
-        text: Union[str, None] = None,
-        filename: Union[str, None] = None,
-        name: Union[str, None] = None,
-        owner_account: Union[Account, None] = None
+        text: str | None = None,
+        filename: str | None = None,
+        name: str | None = None,
+        owner_account: Account | None = None
     ):
         """
 
@@ -141,7 +140,7 @@ def send(self, transaction: str, account: Account):
             raise ValueError(f'No contract address found for {self._name}')
         return self._convex.send(f'(call #{self._address} {transaction})', account)
 
-    def query(self, transaction: str, account_address: Union[Account, int, str, None] = None):
+    def query(self, transaction: str, account_address: Account | int | str | None = None):
         """
 
         Sends a query to the contract.

convex_api/exceptions.py

@@ -5,11 +5,8 @@
 """
 
 
-from typing import Union
-
-
 class ConvexBaseError(Exception):
-    def __init__(self, source: str, code: Union[int, str], text: str):
+    def __init__(self, source: str, code: int | str, text: str):
         self.source = source
         self.code = code
         self.text = text

convex_api/key_pair.py

@@ -4,10 +4,10 @@
 
 
 """
+from __future__ import annotations
 
 import binascii
 import re
-from typing import Union
 
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.backends.openssl.backend import backend as openssl_backend
@@ -109,7 +109,7 @@ def hex_to_bytes(hexstr: str) -> bytes:
             raise ValueError('Invalid hex string')
 
     @staticmethod
-    def to_bytes(data: Union[int, bytes]) -> bytes:
+    def to_bytes(data: int | bytes) -> bytes:
         """
 
         Convert data to bytes.
@@ -225,7 +225,7 @@ def is_public_key(public_key: str) -> bool:
         else:
             return False
 
-    def __init__(self, private_key: Union[Ed25519PrivateKey, None] = None):
+    def __init__(self, private_key: Ed25519PrivateKey | None = None):
         """
 
         Create a new keypair object with a public and private key as a Ed25519PrivateKey. It is better to use
@@ -283,7 +283,7 @@ def sign(self, hash_text: str) -> str:
         signed_hash_bytes = self._private_key.sign(hash_data)
         return KeyPair.to_hex(signed_hash_bytes)
 
-    def export_to_text(self, password: Union[str, bytes]):
+    def export_to_text(self, password: str | bytes):
         """
 
         Export the private key to an encrypted PEM string.
@@ -340,7 +340,7 @@ def export_to_mnemonic(self) -> str:
             encryption_algorithm=serialization.NoEncryption()
         ))
 
-    def export_to_file(self, filename: str, password: Union[str, bytes]) -> None:
+    def export_to_file(self, filename: str, password: str | bytes) -> None:
         """
 
         Export the private key to a file. This uses `export_to_text` to export as a string.
@@ -455,7 +455,7 @@ def public_key_checksum(self) -> str:
 
         return KeyPair.to_public_key_checksum(self.public_key)
 
-    def is_equal(self, public_key_pair: Union['KeyPair', str]) -> bool:
+    def is_equal(self, public_key_pair: KeyPair | str) -> bool:
         """
 
         Compare the value to see if it is the same as this key_pair
@@ -473,7 +473,7 @@ def is_equal(self, public_key_pair: Union['KeyPair', str]) -> bool:
         return KeyPair.remove_0x_prefix(self.public_key_checksum).lower() == KeyPair.remove_0x_prefix(public_key).lower()
 
     @staticmethod
-    def import_from_bytes(value: bytes) -> 'KeyPair':
+    def import_from_bytes(value: bytes) -> KeyPair:
         """
 
         Import an keypair from a private key in bytes.
@@ -491,7 +491,7 @@ def import_from_bytes(value: bytes) -> 'KeyPair':
         return KeyPair(Ed25519PrivateKey.from_private_bytes(value))
 
     @staticmethod
-    def import_from_text(text: Union[str, bytes], password: Union[str, bytes]) -> 'KeyPair':
+    def import_from_text(text: str | bytes, password: str | bytes) -> KeyPair:
         """
 
         Import a KeyPair from an encrypted PEM string.
@@ -526,7 +526,7 @@ def import_from_text(text: Union[str, bytes], password: Union[str, bytes]) -> 'K
         return KeyPair(private_key)
 
     @staticmethod
-    def import_from_mnemonic(words: str) -> 'KeyPair':
+    def import_from_mnemonic(words: str) -> KeyPair:
         """
 
         Creates a new KeyPair object using a list of words. These words contain the private key and must be kept secret.
@@ -549,7 +549,7 @@ def import_from_mnemonic(words: str) -> 'KeyPair':
         return KeyPair(Ed25519PrivateKey.from_private_bytes(value))
 
     @staticmethod
-    def import_from_file(filename: str, password: Union[str, bytes]) -> 'KeyPair':
+    def import_from_file(filename: str, password: str | bytes) -> KeyPair:
         """
 
         Load the encrypted private key from file. The file is saved in PEM format encrypted with a password