web3 7.0.0b2__py3-none-any.whl → 7.7.0__py3-none-any.whl

ens/utils.py

@@ -6,8 +6,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Collection,
-    Dict,
-    List,
     Optional,
     Sequence,
     Tuple,
@@ -28,16 +26,15 @@ from eth_utils import (
     to_bytes,
     to_normalized_address,
 )
-from eth_utils.abi import (
-    collapse_if_tuple,
-)
 from hexbytes import (
     HexBytes,
 )
 
-from ._normalization import (
-    normalize_name_ensip15,
+from ens.exceptions import (
+    ENSTypeError,
+    ENSValueError,
 )
+
 from .constants import (
     ACCEPTABLE_STALE_HOURS,
     AUCTION_START_GAS_CONSTANT,
@@ -66,9 +63,6 @@ if TYPE_CHECKING:
         AsyncBaseProvider,
         BaseProvider,
     )
-    from web3.types import (  # noqa: F401
-        ABIFunction,
-    )
 
 
 def Web3() -> Type["_Web3"]:
@@ -80,7 +74,7 @@ def Web3() -> Type["_Web3"]:
 
 
 def init_web3(
-    provider: "BaseProvider" = cast("BaseProvider", default),
+    provider: "BaseProvider" = None,
     middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
 ) -> "_Web3":
     from web3 import (
@@ -90,6 +84,7 @@ def init_web3(
         Eth as EthMain,
     )
 
+    provider = provider or cast("BaseProvider", default)
     if provider is default:
         w3 = Web3Main(ens=None, modules={"eth": (EthMain)})
     else:
@@ -117,13 +112,18 @@ def customize_web3(w3: "_Web3") -> "_Web3":
 def normalize_name(name: str) -> str:
     """
     Clean the fully qualified name, as defined in ENS `EIP-137
-    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_
+    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_  # blocklint: pragma # noqa: E501
 
     This does *not* enforce whether ``name`` is a label or fully qualified domain.
 
     :param str name: the dot-separated ENS name
     :raises InvalidName: if ``name`` has invalid syntax
     """
+    # Defer import because module initialization takes > 0.1 ms
+    from ._normalization import (
+        normalize_name_ensip15,
+    )
+
     if is_empty_name(name):
         return ""
     elif isinstance(name, (bytes, bytearray)):
@@ -133,7 +133,7 @@ def normalize_name(name: str) -> str:
 
 
 def ens_encode_name(name: str) -> bytes:
-    """
+    r"""
     Encode a name according to DNS standards specified in section 3.1
     of RFC1035 with the following validations:
 
@@ -169,7 +169,7 @@ def ens_encode_name(name: str) -> bytes:
 def is_valid_name(name: str) -> bool:
     """
     Validate whether the fully qualified name is valid, as defined in ENS `EIP-137
-    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_
+    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_  # blocklint: pragma # noqa: E501
 
     :param str name: the dot-separated ENS name
     :returns: True if ``name`` is set, and :meth:`~ens.ENS.nameprep` will not
@@ -197,17 +197,17 @@ def sha3_text(val: Union[str, bytes]) -> HexBytes:
 def label_to_hash(label: str) -> HexBytes:
     label = normalize_name(label)
     if "." in label:
-        raise ValueError(f"Cannot generate hash for label {label!r} with a '.'")
+        raise ENSValueError(f"Cannot generate hash for label {label!r} with a '.'")
     return Web3().keccak(text=label)
 
 
 def normal_name_to_hash(name: str) -> HexBytes:
     """
-    This method will not normalize the name. 'normal' name here means the name
-    should already be normalized before calling this method.
+    Hashes a pre-normalized name.
+    The normalization of the name is a prerequisite and is not handled by this function.
 
-    :param name:            the name to hash - should already be normalized
-    :return: namehash       the hash of the name
+    :param str name: A normalized name string to be hashed.
+    :return: namehash - the hash of the name
     :rtype: HexBytes
     """
     node = EMPTY_SHA3_BYTES
@@ -229,7 +229,7 @@ def raw_name_to_hash(name: str) -> HexBytes:
     behind the scenes. For advanced usage, it is a helpful utility.
 
     This normalizes the name with `nameprep
-    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_
+    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_  # blocklint: pragma # noqa: E501
     before hashing.
 
     :param str name: ENS name to hash
@@ -262,7 +262,7 @@ def assert_signer_in_modifier_kwargs(modifier_kwargs: Any) -> ChecksumAddress:
 
     _modifier_type, modifier_dict = dict(modifier_kwargs).popitem()
     if "from" not in modifier_dict:
-        raise TypeError(ERR_MSG)
+        raise ENSTypeError(ERR_MSG)
 
     return modifier_dict["from"]
 
@@ -285,20 +285,11 @@ def is_valid_ens_name(ens_name: str) -> bool:
     return True
 
 
-# borrowed from similar method at `web3._utils.abi` due to circular dependency
-def get_abi_output_types(abi: "ABIFunction") -> List[str]:
-    return (
-        []
-        if abi["type"] == "fallback"
-        else [collapse_if_tuple(cast(Dict[str, Any], arg)) for arg in abi["outputs"]]
-    )
-
-
 # -- async -- #
 
 
 def init_async_web3(
-    provider: "AsyncBaseProvider" = cast("AsyncBaseProvider", default),
+    provider: "AsyncBaseProvider" = None,
     middleware: Optional[Sequence[Tuple["Middleware", str]]] = (),
 ) -> "AsyncWeb3":
     from web3 import (
@@ -311,8 +302,9 @@ def init_async_web3(
         StalecheckMiddlewareBuilder,
     )
 
+    provider = provider or cast("AsyncBaseProvider", default)
     middleware = list(middleware)
-    for i, (mw, name) in enumerate(middleware):
+    for i, (_mw, name) in enumerate(middleware):
         if name == "ens_name_to_address":
             middleware.pop(i)
 

web3/__init__.py

@@ -1,26 +1,28 @@
 from eth_account import Account  # noqa: E402
-import sys
 
-if sys.version_info.major == 3 and sys.version_info.minor < 8:
-    import pkg_resources
+from importlib.metadata import version
 
-    __version__ = pkg_resources.get_distribution("web3").version
-else:
-    from importlib.metadata import version
-
-    __version__ = version("web3")
+__version__ = version("web3")
 
 
 from web3.main import (
     AsyncWeb3,
     Web3,
 )
+from web3.providers import (
+    AsyncBaseProvider,
+    AutoProvider,
+    BaseProvider,
+    JSONBaseProvider,
+    PersistentConnection,
+)
 from web3.providers.persistent import (  # noqa: E402
     AsyncIPCProvider,
     PersistentConnectionProvider,
     WebSocketProvider,
 )
 from web3.providers.eth_tester import (  # noqa: E402
+    AsyncEthereumTesterProvider,
     EthereumTesterProvider,
 )
 from web3.providers.ipc import (  # noqa: E402
@@ -37,14 +39,23 @@ from web3.providers.legacy_websocket import (  # noqa: E402
 
 __all__ = [
     "__version__",
+    "Account",
+    # web3:
     "AsyncWeb3",
     "Web3",
+    # providers:
+    "AsyncBaseProvider",
+    "AsyncEthereumTesterProvider",
+    "AsyncHTTPProvider",
+    "AsyncIPCProvider",
+    "AutoProvider",
+    "BaseProvider",
+    "EthereumTesterProvider",
     "HTTPProvider",
     "IPCProvider",
+    "JSONBaseProvider",
     "LegacyWebSocketProvider",
+    "PersistentConnection",
+    "PersistentConnectionProvider",
     "WebSocketProvider",
-    "EthereumTesterProvider",
-    "Account",
-    "AsyncHTTPProvider",
-    "AsyncIPCProvider",
 ]