Drop Support for Python 3.8 & 3.9 (#3774)

* Drop 3.8 and 3.9 from CI, run pyupgrade tool for 3.8 -> 3.9

* Move from 3.9 -> 3.10

* Add newsfragment

Author: kclowes

.circleci/config.yml

@@ -221,7 +221,7 @@ workflows:
       - common:
           matrix:
             parameters:
-              python_minor_version: ["8", "9", "10", "11", "12", "13"]
+              python_minor_version: ["10", "11", "12", "13"]
               tox_env: [
                 "lint",
                 "core",
@@ -234,7 +234,7 @@ workflows:
       - geth:
           matrix:
             parameters:
-              python_minor_version: ["8", "9", "10", "11", "12", "13"]
+              python_minor_version: ["10", "11", "12", "13"]
               tox_env: [
                 "integration-goethereum-ipc",
                 "integration-goethereum-ipc_async",
@@ -247,7 +247,7 @@ workflows:
       - docs:
           matrix:
             parameters:
-              python_minor_version: ["9"]
+              python_minor_version: ["10"]
           name: "py3<< matrix.python_minor_version >>-docs"
       - windows-wheel:
           matrix:

.project-template/refill_template_vars.py

@@ -11,7 +11,7 @@ def main():
     template_vars_file = template_dir / "template_vars.txt"
     fill_template_vars_script = template_dir / "fill_template_vars.py"
 
-    with open(template_vars_file, "r") as input_file:
+    with open(template_vars_file) as input_file:
         content_lines = input_file.readlines()
 
     process = subprocess.Popen(

README.md

@@ -10,7 +10,7 @@
 
 web3.py allows you to interact with the Ethereum blockchain using Python, enabling you to build decentralized applications, interact with smart contracts, and much more.
 
-- Python 3.8+ support
+- Python 3.10+ support
 
 ## Installation
 

docs/conf.py

@@ -17,7 +17,7 @@
 import os
 
 DIR = os.path.dirname(__file__)
-with open(os.path.join(DIR, "../setup.py"), "r") as f:
+with open(os.path.join(DIR, "../setup.py")) as f:
     for line in f:
         if "version=" in line:
             setup_version = line.split('"')[1]

ens/_normalization.py

@@ -5,13 +5,7 @@
 import os
 from typing import (
     Any,
-    Dict,
-    List,
     Literal,
-    Optional,
-    Set,
-    Tuple,
-    Union,
 )
 
 from pyunormalize import (
@@ -27,9 +21,9 @@
 
 
 def _json_list_mapping_to_dict(
-    f: Dict[str, Any],
+    f: dict[str, Any],
     list_mapped_key: str,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Takes a `[key, [value]]` mapping from the original ENS spec json files and turns it
     into a `{key: value}` mapping.
@@ -67,17 +61,17 @@ class TokenType(Enum):
 class Token:
     type: Literal[TokenType.TEXT, TokenType.EMOJI]
     _original_text: str
-    _original_codepoints: List[int]
-    _normalized_codepoints: Optional[List[int]] = None
+    _original_codepoints: list[int]
+    _normalized_codepoints: list[int] | None = None
 
     restricted: bool = False
 
-    def __init__(self, codepoints: List[int]) -> None:
+    def __init__(self, codepoints: list[int]) -> None:
         self._original_codepoints = codepoints
         self._original_text = "".join(chr(cp) for cp in codepoints)
 
     @property
-    def codepoints(self) -> List[int]:
+    def codepoints(self) -> list[int]:
         return (
             self._normalized_codepoints
             if self._normalized_codepoints
@@ -99,12 +93,12 @@ class TextToken(Token):
 
 class Label:
     type: str
-    tokens: List[Token]
+    tokens: list[Token]
 
     def __init__(
         self,
         type: str = None,
-        tokens: List[Token] = None,
+        tokens: list[Token] = None,
     ) -> None:
         self.type = type
         self.tokens = tokens
@@ -118,9 +112,9 @@ def text(self) -> str:
 
 
 class ENSNormalizedName:
-    labels: List[Label]
+    labels: list[Label]
 
-    def __init__(self, normalized_labels: List[Label]) -> None:
+    def __init__(self, normalized_labels: list[Label]) -> None:
         self.labels = normalized_labels
 
     @property
@@ -140,28 +134,28 @@ def as_text(self) -> str:
 }
 
 
-def _extract_valid_codepoints() -> Set[int]:
+def _extract_valid_codepoints() -> set[int]:
     all_valid = set()
     for _name, valid_cps in VALID_BY_GROUPS.items():
         all_valid.update(valid_cps)
     all_valid.update(map(ord, NFD("".join(map(chr, all_valid)))))
     return all_valid
 
 
-def _construct_whole_confusable_map() -> Dict[int, Set[str]]:
+def _construct_whole_confusable_map() -> dict[int, set[str]]:
     """
     Create a mapping, per confusable, that contains all the groups in the cp's whole
     confusable excluding the confusable extent of the cp itself - as per the spec at
     https://docs.ens.domains/ens-improvement-proposals/ensip-15-normalization-standard
     """
-    whole_map: Dict[int, Set[str]] = {}
+    whole_map: dict[int, set[str]] = {}
     for whole in NORMALIZATION_SPEC["wholes"]:
-        whole_confusables: Set[int] = set(whole["valid"] + whole["confused"])
-        confusable_extents: List[Tuple[Set[int], Set[str]]] = []
+        whole_confusables: set[int] = set(whole["valid"] + whole["confused"])
+        confusable_extents: list[tuple[set[int], set[str]]] = []
 
         for confusable_cp in whole_confusables:
             # create confusable extents for all whole confusables
-            groups: Set[str] = set()
+            groups: set[str] = set()
             for gn, gv in VALID_BY_GROUPS.items():
                 if confusable_cp in gv:
                     groups.add(gn)
@@ -181,7 +175,7 @@ def _construct_whole_confusable_map() -> Dict[int, Set[str]]:
                     confusable_extents.append(({confusable_cp}, groups))
 
         for confusable_cp in whole_confusables:
-            confusable_cp_extent_groups: Set[str] = set()
+            confusable_cp_extent_groups: set[str] = set()
 
             if confusable_cp in whole["confused"]:
                 whole_map[confusable_cp] = set()
@@ -209,13 +203,13 @@ def _is_fenced(cp: int) -> bool:
     return cp in [fenced[0] for fenced in NORMALIZATION_SPEC["fenced"]]
 
 
-def _codepoints_to_text(cps: Union[List[List[int]], List[int]]) -> str:
+def _codepoints_to_text(cps: list[list[int]] | list[int]) -> str:
     return "".join(
         chr(cp) if isinstance(cp, int) else _codepoints_to_text(cp) for cp in cps
     )
 
 
-def _validate_tokens_and_get_label_type(tokens: List[Token]) -> str:
+def _validate_tokens_and_get_label_type(tokens: list[Token]) -> str:
     """
     Validate tokens and return the label type.
 
@@ -388,7 +382,7 @@ def _validate_tokens_and_get_label_type(tokens: List[Token]) -> str:
     return chars_group_name
 
 
-def _build_and_validate_label_from_tokens(tokens: List[Token]) -> Label:
+def _build_and_validate_label_from_tokens(tokens: list[Token]) -> Label:
     for token in tokens:
         if token.type == TokenType.TEXT:
             # apply NFC normalization to text tokens
@@ -404,7 +398,7 @@ def _build_and_validate_label_from_tokens(tokens: List[Token]) -> Label:
     return label
 
 
-def _buffer_codepoints_to_chars(buffer: Union[List[int], List[List[int]]]) -> str:
+def _buffer_codepoints_to_chars(buffer: list[int] | list[list[int]]) -> str:
     return "".join(
         "".join(chr(c) for c in char) if isinstance(char, list) else chr(char)
         for char in buffer
@@ -438,8 +432,8 @@ def normalize_name_ensip15(name: str) -> ENSNormalizedName:
         # _input takes the label and breaks it into a list of unicode code points
         # e.g. "xyz👨🏻" -> [120, 121, 122, 128104, 127995]
         _input = [ord(c) for c in label_str]
-        buffer: List[int] = []
-        tokens: List[Token] = []
+        buffer: list[int] = []
+        tokens: list[Token] = []
 
         while len(_input) > 0:
             emoji_codepoint = None

ens/async_ens.py

@@ -7,8 +7,6 @@
     Coroutine,
     Optional,
     Sequence,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -103,8 +101,8 @@ class AsyncENS(BaseENS):
     def __init__(
         self,
         provider: Optional["AsyncBaseProvider"] = None,
-        addr: Optional[ChecksumAddress] = None,
-        middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
+        addr: ChecksumAddress | None = None,
+        middleware: Sequence[tuple["Middleware", str]] | None = None,
     ) -> None:
         """
         :param provider: a single provider used to connect to Ethereum
@@ -137,7 +135,11 @@ def from_web3(
         """
         provider = w3.manager.provider
         middleware = w3.middleware_onion.middleware
-        ns = cls(cast("AsyncBaseProvider", provider), addr=addr, middleware=middleware)
+        ns = cls(
+            cast("AsyncBaseProvider", provider),
+            addr=addr,
+            middleware=middleware,
+        )
 
         # inherit strict bytes checking from w3 instance
         ns.strict_bytes_type_checking = w3.strict_bytes_type_checking
@@ -147,8 +149,8 @@ def from_web3(
     async def address(
         self,
         name: str,
-        coin_type: Optional[int] = None,
-    ) -> Optional[ChecksumAddress]:
+        coin_type: int | None = None,
+    ) -> ChecksumAddress | None:
         """
         Look up the Ethereum address that `name` currently points to.
 
@@ -163,7 +165,10 @@ async def address(
         else:
             r = await self.resolver(name)
             await _async_validate_resolver_and_interface_id(
-                name, r, ENS_MULTICHAIN_ADDRESS_INTERFACE_ID, "addr(bytes32,uint256)"
+                name,
+                r,
+                ENS_MULTICHAIN_ADDRESS_INTERFACE_ID,
+                "addr(bytes32,uint256)",
             )
             node = raw_name_to_hash(name)
             address_as_bytes = await r.caller.addr(node, coin_type)
@@ -174,12 +179,12 @@ async def address(
     async def setup_address(
         self,
         name: str,
-        address: Union[Address, ChecksumAddress, HexAddress] = cast(  # noqa: B008
-            ChecksumAddress, default
-        ),
-        coin_type: Optional[int] = None,
+        address: Address
+        | ChecksumAddress
+        | HexAddress = cast(ChecksumAddress, default),  # noqa: B008
+        coin_type: int | None = None,
         transact: Optional["TxParams"] = None,
-    ) -> Optional[HexBytes]:
+    ) -> HexBytes | None:
         """
         Set up the name to point to the supplied address.
         The sender of the transaction must own the name, or
@@ -228,7 +233,7 @@ async def setup_address(
                 transact
             )
 
-    async def name(self, address: ChecksumAddress) -> Optional[str]:
+    async def name(self, address: ChecksumAddress) -> str | None:
         """
         Look up the name that the address points to, using a
         reverse lookup. Reverse lookup is opt-in for name owners.
@@ -248,7 +253,7 @@ async def name(self, address: ChecksumAddress) -> Optional[str]:
     async def setup_name(
         self,
         name: str,
-        address: Optional[ChecksumAddress] = None,
+        address: ChecksumAddress | None = None,
         transact: Optional["TxParams"] = None,
     ) -> HexBytes:
         """
@@ -314,7 +319,7 @@ async def setup_owner(
         name: str,
         new_owner: ChecksumAddress = None,
         transact: Optional["TxParams"] = None,
-    ) -> Optional[ChecksumAddress]:
+    ) -> ChecksumAddress | None:
         """
         Set the owner of the supplied name to `new_owner`.
 
@@ -437,7 +442,7 @@ async def _get_resolver(
         self,
         normal_name: str,
         fn_name: str = "addr",
-    ) -> Tuple[Optional["AsyncContract"], str]:
+    ) -> tuple[Optional["AsyncContract"], str]:
         current_name = normal_name
 
         # look for a resolver, starting at the full name and taking the
@@ -454,7 +459,8 @@ async def _get_resolver(
             if not is_none_or_zero_address(resolver_addr):
                 # if resolver found, return it
                 resolver = cast(
-                    "AsyncContract", self._type_aware_resolver(resolver_addr, fn_name)
+                    "AsyncContract",
+                    self._type_aware_resolver(resolver_addr, fn_name),
                 )
                 return resolver, current_name
 
@@ -464,7 +470,7 @@ async def _get_resolver(
     async def _set_resolver(
         self,
         name: str,
-        resolver_addr: Optional[ChecksumAddress] = None,
+        resolver_addr: ChecksumAddress | None = None,
         transact: Optional["TxParams"] = None,
     ) -> "AsyncContract":
         if not transact:
@@ -487,7 +493,7 @@ async def _resolve(
         self,
         name: str,
         fn_name: str = "addr",
-    ) -> Optional[Union[ChecksumAddress, str]]:
+    ) -> ChecksumAddress | str | None:
         normal_name = normalize_name(name)
 
         resolver, current_name = await self._get_resolver(normal_name, fn_name)
@@ -523,7 +529,7 @@ async def _assert_control(
         self,
         account: ChecksumAddress,
         name: str,
-        parent_owned: Optional[str] = None,
+        parent_owned: str | None = None,
     ) -> None:
         if not address_in(account, await self.w3.eth.accounts):
             raise UnauthorizedError(
@@ -533,7 +539,7 @@ async def _assert_control(
 
     async def _first_owner(
         self, name: str
-    ) -> Tuple[Optional[ChecksumAddress], Sequence[str], str]:
+    ) -> tuple[ChecksumAddress | None, Sequence[str], str]:
         """
         Takes a name, and returns the owner of the deepest subdomain that has an owner
 
@@ -554,7 +560,7 @@ async def _claim_ownership(
         owner: ChecksumAddress,
         unowned: Sequence[str],
         owned: str,
-        old_owner: Optional[ChecksumAddress] = None,
+        old_owner: ChecksumAddress | None = None,
         transact: Optional["TxParams"] = None,
     ) -> None:
         if not transact:
@@ -575,7 +581,7 @@ async def _claim_ownership(
 
     async def _setup_reverse(
         self,
-        name: Optional[str],
+        name: str | None,
         address: ChecksumAddress,
         transact: Optional["TxParams"] = None,
     ) -> HexBytes: