web3 7.14.1__py3-none-any.whl → 8.0.0b1__py3-none-any.whl

ens/_normalization.py

@@ -5,13 +5,7 @@ import json
 import os
 from typing import (
     Any,
-    Dict,
-    List,
     Literal,
-    Optional,
-    Set,
-    Tuple,
-    Union,
 )
 
 from pyunormalize import (
@@ -27,9 +21,9 @@ from .exceptions import (
 
 
 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 @@ class Label:
 
 
 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,7 +134,7 @@ VALID_BY_GROUPS = {
 }
 
 
-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)
@@ -148,20 +142,20 @@ def _extract_valid_codepoints() -> Set[int]:
     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 @@ from typing import (
     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 @@ class AsyncENS(BaseENS):
         """
         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 @@ class AsyncENS(BaseENS):
     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 @@ class AsyncENS(BaseENS):
         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 @@ class AsyncENS(BaseENS):
     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 @@ class AsyncENS(BaseENS):
                 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 @@ class AsyncENS(BaseENS):
     async def setup_name(
         self,
         name: str,
-        address: Optional[ChecksumAddress] = None,
+        address: ChecksumAddress | None = None,
         transact: Optional["TxParams"] = None,
     ) -> HexBytes:
         """
@@ -314,7 +319,7 @@ class AsyncENS(BaseENS):
         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 @@ class AsyncENS(BaseENS):
         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 @@ class AsyncENS(BaseENS):
             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 @@ class AsyncENS(BaseENS):
     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 @@ class AsyncENS(BaseENS):
         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 @@ class AsyncENS(BaseENS):
         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 @@ class AsyncENS(BaseENS):
 
     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 @@ class AsyncENS(BaseENS):
         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 @@ class AsyncENS(BaseENS):
 
     async def _setup_reverse(
         self,
-        name: Optional[str],
+        name: str | None,
         address: ChecksumAddress,
         transact: Optional["TxParams"] = None,
     ) -> HexBytes:

ens/base_ens.py

@@ -4,7 +4,6 @@ from functools import (
 from typing import (
     TYPE_CHECKING,
     Any,
-    Type,
     Union,
 )
 
@@ -40,8 +39,8 @@ if TYPE_CHECKING:
 class BaseENS:
     w3: Union["AsyncWeb3[Any]", "Web3"] = None
     ens: Union["Contract", "AsyncContract"] = None
-    _resolver_contract: Union[Type["Contract"], Type["AsyncContract"]] = None
-    _reverse_resolver_contract: Union[Type["Contract"], Type["AsyncContract"]] = None
+    _resolver_contract: type["Contract"] | type["AsyncContract"] = None
+    _reverse_resolver_contract: type["Contract"] | type["AsyncContract"] = None
 
     @property
     def strict_bytes_type_checking(self) -> bool:

ens/ens.py

@@ -6,8 +6,6 @@ from typing import (
     Any,
     Optional,
     Sequence,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -100,7 +98,7 @@ class ENS(BaseENS):
         self,
         provider: "BaseProvider" = None,
         addr: ChecksumAddress = None,
-        middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
+        middleware: Sequence[tuple["Middleware", str]] | None = None,
     ) -> None:
         """
         :param provider: a single provider used to connect to Ethereum
@@ -142,8 +140,8 @@ class ENS(BaseENS):
     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.
 
@@ -172,12 +170,12 @@ class ENS(BaseENS):
     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
@@ -227,7 +225,7 @@ class ENS(BaseENS):
                 transact
             )
 
-    def name(self, address: ChecksumAddress) -> Optional[str]:
+    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.
@@ -245,7 +243,7 @@ class ENS(BaseENS):
     def setup_name(
         self,
         name: str,
-        address: Optional[ChecksumAddress] = None,
+        address: ChecksumAddress | None = None,
         transact: Optional["TxParams"] = None,
     ) -> HexBytes:
         """
@@ -311,7 +309,7 @@ class ENS(BaseENS):
         name: str,
         new_owner: ChecksumAddress = None,
         transact: Optional["TxParams"] = None,
-    ) -> Optional[ChecksumAddress]:
+    ) -> ChecksumAddress | None:
         """
         Set the owner of the supplied name to `new_owner`.
 
@@ -428,7 +426,7 @@ class ENS(BaseENS):
         self,
         normal_name: str,
         fn_name: str = "addr",
-    ) -> Tuple[Optional["Contract"], str]:
+    ) -> tuple[Optional["Contract"], str]:
         current_name = normal_name
 
         # look for a resolver, starting at the full name and taking the parent
@@ -453,7 +451,7 @@ class ENS(BaseENS):
     def _set_resolver(
         self,
         name: str,
-        resolver_addr: Optional[ChecksumAddress] = None,
+        resolver_addr: ChecksumAddress | None = None,
         transact: Optional["TxParams"] = None,
     ) -> "Contract":
         if not transact:
@@ -468,7 +466,7 @@ class ENS(BaseENS):
 
     def _resolve(
         self, name: str, fn_name: str = "addr"
-    ) -> Optional[Union[ChecksumAddress, str]]:
+    ) -> ChecksumAddress | str | None:
         normal_name = normalize_name(name)
         resolver, current_name = self._get_resolver(normal_name, fn_name)
         if not resolver:
@@ -501,7 +499,7 @@ class ENS(BaseENS):
         self,
         account: ChecksumAddress,
         name: str,
-        parent_owned: Optional[str] = None,
+        parent_owned: str | None = None,
     ) -> None:
         if not address_in(account, self.w3.eth.accounts):
             raise UnauthorizedError(
@@ -511,7 +509,7 @@ class ENS(BaseENS):
 
     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
 
@@ -532,7 +530,7 @@ class ENS(BaseENS):
         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:
@@ -549,7 +547,7 @@ class ENS(BaseENS):
 
     def _setup_reverse(
         self,
-        name: Optional[str],
+        name: str | None,
         address: ChecksumAddress,
         transact: Optional["TxParams"] = None,
     ) -> HexBytes:

ens/utils.py

@@ -6,11 +6,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Collection,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
-    Union,
     cast,
 )
 import warnings
@@ -66,7 +62,7 @@ if TYPE_CHECKING:
     )
 
 
-def Web3() -> Type["_Web3"]:
+def Web3() -> type["_Web3"]:
     from web3 import (
         Web3 as Web3Main,
     )
@@ -76,7 +72,7 @@ def Web3() -> Type["_Web3"]:
 
 def init_web3(
     provider: "BaseProvider" = None,
-    middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
+    middleware: Sequence[tuple["Middleware", str]] | None = None,
 ) -> "_Web3":
     from web3 import (
         Web3 as Web3Main,
@@ -195,11 +191,11 @@ def is_valid_name(name: str) -> bool:
         return False
 
 
-def to_utc_datetime(timestamp: float) -> Optional[datetime]:
+def to_utc_datetime(timestamp: float) -> datetime | None:
     return datetime.fromtimestamp(timestamp, timezone.utc) if timestamp else None
 
 
-def sha3_text(val: Union[str, bytes]) -> HexBytes:
+def sha3_text(val: str | bytes) -> HexBytes:
     if isinstance(val, str):
         val = val.encode("utf-8")
     return Web3().keccak(val)
@@ -278,7 +274,7 @@ def assert_signer_in_modifier_kwargs(modifier_kwargs: Any) -> ChecksumAddress:
     return modifier_dict["from"]
 
 
-def is_none_or_zero_address(addr: Union[Address, ChecksumAddress, HexAddress]) -> bool:
+def is_none_or_zero_address(addr: Address | ChecksumAddress | HexAddress) -> bool:
     return not addr or addr == EMPTY_ADDR_HEX
 
 
@@ -301,7 +297,7 @@ def is_valid_ens_name(ens_name: str) -> bool:
 
 def init_async_web3(
     provider: "AsyncBaseProvider" = None,
-    middleware: Optional[Sequence[Tuple["Middleware", str]]] = (),
+    middleware: Sequence[tuple["Middleware", str]] | None = (),
 ) -> "AsyncWeb3[Any]":
     from web3 import (
         AsyncWeb3 as AsyncWeb3Main,

web3/__init__.py

@@ -32,9 +32,6 @@ from web3.providers.rpc import (  # noqa: E402
     AsyncHTTPProvider,
     HTTPProvider,
 )
-from web3.providers.legacy_websocket import (  # noqa: E402
-    LegacyWebSocketProvider,
-)
 
 
 __all__ = [
@@ -54,7 +51,6 @@ __all__ = [
     "HTTPProvider",
     "IPCProvider",
     "JSONBaseProvider",
-    "LegacyWebSocketProvider",
     "PersistentConnection",
     "PersistentConnectionProvider",
     "WebSocketProvider",