web3 6.20.2__py3-none-any.whl → 7.0.0__py3-none-any.whl

ens/__init__.py

@@ -1,5 +1,3 @@
-# flake8: noqa
-
 from .async_ens import (
     AsyncENS,
 )
@@ -18,3 +16,16 @@ from .exceptions import (
     UnderfundedBid,
     UnownedName,
 )
+
+__all__ = [
+    "AsyncENS",
+    "BaseENS",
+    "ENS",
+    "AddressMismatch",
+    "BidTooLow",
+    "InvalidLabel",
+    "InvalidName",
+    "UnauthorizedError",
+    "UnderfundedBid",
+    "UnownedName",
+]

ens/_normalization.py

@@ -3,13 +3,11 @@ from enum import (
 )
 import json
 import os
-from sys import (
-    version_info,
-)
 from typing import (
     Any,
     Dict,
     List,
+    Literal,
     Optional,
     Set,
     Tuple,
@@ -25,17 +23,6 @@ from .exceptions import (
     InvalidName,
 )
 
-# TODO: remove once web3 supports python>=3.8
-if version_info >= (3, 8):
-    from typing import (
-        Literal,
-    )
-else:
-    from typing_extensions import (  # type: ignore
-        Literal,
-    )
-
-
 # -- setup -- #
 
 
@@ -61,7 +48,7 @@ with open(os.path.join(specs_dir_path, "normalization_spec.json")) as spec:
     # clean `FE0F` (65039) from entries since it's optional
     for e in NORMALIZATION_SPEC["emoji"]:
         if 65039 in e:
-            for i in range(e.count(65039)):
+            for _ in range(e.count(65039)):
                 e.remove(65039)
 
 with open(os.path.join(specs_dir_path, "nf.json")) as nf:
@@ -235,7 +222,6 @@ def _validate_tokens_and_get_label_type(tokens: List[Token]) -> str:
     :param List[Token] tokens: the tokens to validate
     :raises InvalidName: if any of the tokens are invalid
     """
-
     if all(token.type == TokenType.EMOJI for token in tokens):
         return "emoji"
 
@@ -436,7 +422,6 @@ def normalize_name_ensip15(name: str) -> ENSNormalizedName:
     :param str name: the dot-separated ENS name
     :raises InvalidName: if ``name`` has invalid syntax
     """
-
     if not name:
         raise InvalidName("Name cannot be empty")
     elif isinstance(name, (bytes, bytearray)):

ens/async_ens.py

@@ -4,6 +4,7 @@ from copy import (
 from typing import (
     TYPE_CHECKING,
     Any,
+    Coroutine,
     Optional,
     Sequence,
     Tuple,
@@ -46,6 +47,7 @@ from ens.constants import (
 )
 from ens.exceptions import (
     AddressMismatch,
+    ENSValueError,
     ResolverNotFound,
     UnauthorizedError,
     UnownedName,
@@ -71,12 +73,14 @@ if TYPE_CHECKING:
         AsyncContractFunction,
     )
     from web3.main import AsyncWeb3  # noqa: F401
+    from web3.middleware.base import (  # noqa: F401
+        Middleware,
+    )
     from web3.providers import (  # noqa: F401
         AsyncBaseProvider,
         BaseProvider,
     )
     from web3.types import (  # noqa: F401
-        AsyncMiddleware,
         TxParams,
     )
 
@@ -87,7 +91,7 @@ class AsyncENS(BaseENS):
     like getting the address for a name.
 
     Unless otherwise specified, all addresses are assumed to be a `str` in
-    `checksum format <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md>`_,
+    `checksum format <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md>`_,  # blocklint: pragma # noqa: E501
     like: ``"0x314159265dD8dbb310642f98f50C066173C1259b"``
     """
 
@@ -96,9 +100,9 @@ class AsyncENS(BaseENS):
 
     def __init__(
         self,
-        provider: "AsyncBaseProvider" = cast("AsyncBaseProvider", default),
+        provider: "AsyncBaseProvider" = None,
         addr: ChecksumAddress = None,
-        middlewares: Optional[Sequence[Tuple["AsyncMiddleware", str]]] = None,
+        middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
     ) -> None:
         """
         :param provider: a single provider used to connect to Ethereum
@@ -106,7 +110,8 @@ class AsyncENS(BaseENS):
         :param hex-string addr: the address of the ENS registry on-chain.
             If not provided, ENS.py will default to the mainnet ENS registry address.
         """
-        self.w3 = init_async_web3(provider, middlewares)
+        provider = provider or cast("AsyncBaseProvider", default)
+        self.w3 = init_async_web3(provider, middleware)
 
         ens_addr = addr if addr else ENS_MAINNET_ADDR
         self.ens = self.w3.eth.contract(abi=abis.ENS, address=ens_addr)
@@ -127,10 +132,8 @@ class AsyncENS(BaseENS):
             provided, defaults to the mainnet ENS registry address.
         """
         provider = w3.manager.provider
-        middlewares = w3.middleware_onion.middlewares
-        ns = cls(
-            cast("AsyncBaseProvider", provider), addr=addr, middlewares=middlewares
-        )
+        middleware = w3.middleware_onion.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
@@ -167,7 +170,7 @@ class AsyncENS(BaseENS):
     async def setup_address(
         self,
         name: str,
-        address: Union[Address, ChecksumAddress, HexAddress] = cast(
+        address: Union[Address, ChecksumAddress, HexAddress] = cast(  # noqa: B008
             ChecksumAddress, default
         ),
         coin_type: Optional[int] = None,
@@ -204,7 +207,7 @@ class AsyncENS(BaseENS):
         elif is_binary_address(address):
             address = to_checksum_address(cast(str, address))
         elif not is_checksum_address(address):
-            raise ValueError("You must supply the address in checksum format")
+            raise ENSValueError("You must supply the address in checksum format")
         if await self.address(name) == address:
             return None
         if address is None:
@@ -282,7 +285,7 @@ class AsyncENS(BaseENS):
             if is_binary_address(address):
                 address = to_checksum_address(address)
             if not is_checksum_address(address):
-                raise ValueError("You must supply the address in checksum format")
+                raise ENSValueError("You must supply the address in checksum format")
             await self._assert_control(address, name)
             if not resolved:
                 await self.setup_address(name, address, transact=transact)
@@ -305,7 +308,7 @@ class AsyncENS(BaseENS):
     async def setup_owner(
         self,
         name: str,
-        new_owner: ChecksumAddress = cast(ChecksumAddress, default),
+        new_owner: ChecksumAddress = None,
         transact: Optional["TxParams"] = None,
     ) -> Optional[ChecksumAddress]:
         """
@@ -332,6 +335,7 @@ class AsyncENS(BaseENS):
         :raises UnauthorizedError: if ``'from'`` in `transact` does not own `name`
         :returns: the new owner's address
         """
+        new_owner = new_owner or cast(ChecksumAddress, default)
         if not transact:
             transact = {}
         transact = deepcopy(transact)
@@ -466,9 +470,13 @@ class AsyncENS(BaseENS):
             resolver_addr = await self.address("resolver.eth")
         namehash = raw_name_to_hash(name)
         if await self.ens.caller.resolver(namehash) != resolver_addr:
-            await self.ens.functions.setResolver(  # type: ignore
-                namehash, resolver_addr
-            ).transact(transact)
+            coro = cast(
+                Coroutine[Any, Any, HexBytes],
+                self.ens.functions.setResolver(namehash, resolver_addr).transact(
+                    transact
+                ),
+            )
+            await coro
         return cast("AsyncContract", self._resolver_contract(address=resolver_addr))
 
     async def _resolve(
@@ -550,11 +558,15 @@ class AsyncENS(BaseENS):
         transact = deepcopy(transact)
         transact["from"] = old_owner or owner
         for label in reversed(unowned):
-            await self.ens.functions.setSubnodeOwner(  # type: ignore
-                raw_name_to_hash(owned),
-                label_to_hash(label),
-                owner,
-            ).transact(transact)
+            coro = cast(
+                Coroutine[Any, Any, HexBytes],
+                self.ens.functions.setSubnodeOwner(
+                    raw_name_to_hash(owned),
+                    label_to_hash(label),
+                    owner,
+                ).transact(transact),
+            )
+            await coro
             owned = f"{label}.{owned}"
 
     async def _setup_reverse(

ens/base_ens.py

@@ -11,13 +11,15 @@ from typing import (
 from eth_typing import (
     ChecksumAddress,
 )
+from eth_utils.abi import (
+    get_abi_output_types,
+)
 from hexbytes import (
     HexBytes,
 )
 
 from .utils import (
     address_to_reverse_domain,
-    get_abi_output_types,
     is_valid_name,
     label_to_hash,
     normalize_name,

ens/ens.py

@@ -46,6 +46,7 @@ from .constants import (
 )
 from .exceptions import (
     AddressMismatch,
+    ENSValueError,
     ResolverNotFound,
     UnauthorizedError,
     UnownedName,
@@ -71,11 +72,13 @@ if TYPE_CHECKING:
         Contract,
         ContractFunction,
     )
+    from web3.middleware.base import (  # noqa: F401
+        Middleware,
+    )
     from web3.providers import (  # noqa: F401
         BaseProvider,
     )
     from web3.types import (  # noqa: F401
-        Middleware,
         TxParams,
     )
 
@@ -86,7 +89,7 @@ class ENS(BaseENS):
     like getting the address for a name.
 
     Unless otherwise specified, all addresses are assumed to be a `str` in
-    `checksum format <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md>`_,
+    `checksum format <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md>`_,  # blocklint: pragma # noqa: E501
     like: ``"0x314159265dD8dbb310642f98f50C066173C1259b"``
     """
 
@@ -95,9 +98,9 @@ class ENS(BaseENS):
 
     def __init__(
         self,
-        provider: "BaseProvider" = cast("BaseProvider", default),
+        provider: "BaseProvider" = None,
         addr: ChecksumAddress = None,
-        middlewares: Optional[Sequence[Tuple["Middleware", str]]] = None,
+        middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
     ) -> None:
         """
         :param provider: a single provider used to connect to Ethereum
@@ -106,7 +109,8 @@ class ENS(BaseENS):
             If not provided, ENS.py will default to the mainnet ENS
             registry address.
         """
-        self.w3 = init_web3(provider, middlewares)
+        provider = provider or cast("BaseProvider", default)
+        self.w3 = init_web3(provider, middleware)
 
         ens_addr = addr if addr else ENS_MAINNET_ADDR
         self.ens = self.w3.eth.contract(abi=abis.ENS, address=ens_addr)
@@ -127,8 +131,8 @@ class ENS(BaseENS):
             provided, defaults to the mainnet ENS registry address.
         """
         provider = w3.manager.provider
-        middlewares = w3.middleware_onion.middlewares
-        ns = cls(cast("BaseProvider", provider), addr=addr, middlewares=middlewares)
+        middleware = w3.middleware_onion.middleware
+        ns = cls(cast("BaseProvider", provider), addr=addr, middleware=middleware)
 
         # inherit strict bytes checking from w3 instance
         ns.strict_bytes_type_checking = w3.strict_bytes_type_checking
@@ -168,7 +172,7 @@ class ENS(BaseENS):
     def setup_address(
         self,
         name: str,
-        address: Union[Address, ChecksumAddress, HexAddress] = cast(
+        address: Union[Address, ChecksumAddress, HexAddress] = cast(  # noqa: B008
             ChecksumAddress, default
         ),
         coin_type: Optional[int] = None,
@@ -206,7 +210,7 @@ class ENS(BaseENS):
         elif is_binary_address(address):
             address = to_checksum_address(cast(str, address))
         elif not is_checksum_address(address):
-            raise ValueError("You must supply the address in checksum format")
+            raise ENSValueError("You must supply the address in checksum format")
         if self.address(name) == address:
             return None
         if address is None:
@@ -282,7 +286,7 @@ class ENS(BaseENS):
             if is_binary_address(address):
                 address = to_checksum_address(address)
             if not is_checksum_address(address):
-                raise ValueError("You must supply the address in checksum format")
+                raise ENSValueError("You must supply the address in checksum format")
             self._assert_control(address, name)
             if not resolved:
                 self.setup_address(name, address, transact=transact)
@@ -305,7 +309,7 @@ class ENS(BaseENS):
     def setup_owner(
         self,
         name: str,
-        new_owner: ChecksumAddress = cast(ChecksumAddress, default),
+        new_owner: ChecksumAddress = None,
         transact: Optional["TxParams"] = None,
     ) -> Optional[ChecksumAddress]:
         """
@@ -332,6 +336,7 @@ class ENS(BaseENS):
         :raises UnauthorizedError: if ``'from'`` in `transact` does not own `name`
         :returns: the new owner's address
         """
+        new_owner = new_owner or cast(ChecksumAddress, default)
         if not transact:
             transact = {}
 

ens/exceptions.py

@@ -1,6 +1,3 @@
-from eth_utils import (
-    ValidationError,
-)
 import idna
 
 
@@ -9,7 +6,19 @@ class ENSException(Exception):
     Base class for all ENS Errors
     """
 
-    pass
+
+class ENSValueError(ENSException, ValueError):
+    """
+    An ENS exception wrapper for `ValueError`, for better control over
+    exception handling.
+    """
+
+
+class ENSTypeError(ENSException, TypeError):
+    """
+    An ENS exception wrapper for `TypeError`, for better control over
+    exception handling.
+    """
 
 
 class AddressMismatch(ENSException):
@@ -19,18 +28,14 @@ class AddressMismatch(ENSException):
     not currently point to the address.
     """
 
-    pass
-
 
 class InvalidName(idna.IDNAError, ENSException):
     """
-    This exception is raised if the provided name does not meet
-    the normalization standards specified in `ENSIP-15
+    Raised if the provided name does not meet the normalization
+    standards specified in `ENSIP-15
     <https://docs.ens.domains/ens-improvement-proposals/ensip-15-normalization-standard>`_.
     """
 
-    pass
-
 
 class UnauthorizedError(ENSException):
     """
@@ -39,8 +44,6 @@ class UnauthorizedError(ENSException):
     ``transact`` keyword argument to the owner of the name.
     """
 
-    pass
-
 
 class UnownedName(ENSException):
     """
@@ -50,48 +53,36 @@ class UnownedName(ENSException):
     first with :meth:`~ens.ENS.setup_address`.
     """
 
-    pass
-
 
 class ResolverNotFound(ENSException):
     """
     Raised if no resolver was found for the name you are trying to resolve.
     """
 
-    pass
-
 
 class UnsupportedFunction(ENSException):
     """
     Raised if a resolver does not support a particular method.
     """
 
-    pass
-
 
 class BidTooLow(ENSException):
     """
     Raised if you bid less than the minimum amount
     """
 
-    pass
-
 
 class InvalidBidHash(ENSException):
     """
     Raised if you supply incorrect data to generate the bid hash.
     """
 
-    pass
-
 
 class InvalidLabel(ENSException):
     """
     Raised if you supply an invalid label
     """
 
-    pass
-
 
 class OversizeTransaction(ENSException):
     """
@@ -101,8 +92,6 @@ class OversizeTransaction(ENSException):
     For example: when you try to start too many auctions at once.
     """
 
-    pass
-
 
 class UnderfundedBid(ENSException):
     """
@@ -110,10 +99,8 @@ class UnderfundedBid(ENSException):
     as your intent to bid.
     """
 
-    pass
-
 
-class ENSValidationError(ENSException, ValidationError):
+class ENSValidationError(ENSException):
     """
     Raised if there is a validation error
     """