web3 7.0.0b2__py3-none-any.whl → 7.0.0b4__py3-none-any.whl

web3/exceptions.py

@@ -30,6 +30,44 @@ class Web3Exception(Exception):
             # deal with other exceptions
     """
 
+    def __init__(
+        self,
+        *args: Any,
+        user_message: Optional[str] = None,
+    ):
+        super().__init__(*args)
+
+        # Assign properties of Web3Exception
+        self.user_message = user_message
+
+
+class Web3AssertionError(Web3Exception, AssertionError):
+    """
+    A web3.py exception wrapper for `AssertionError`, for better control over
+    exception handling.
+    """
+
+
+class Web3ValueError(Web3Exception, ValueError):
+    """
+    A web3.py exception wrapper for `ValueError`, for better control over
+    exception handling.
+    """
+
+
+class Web3AttributeError(Web3Exception, AttributeError):
+    """
+    A web3.py exception wrapper for `AttributeError`, for better control over
+    exception handling.
+    """
+
+
+class Web3TypeError(Web3Exception, TypeError):
+    """
+    A web3.py exception wrapper for `TypeError`, for better control over
+    exception handling.
+    """
+
 
 class BadFunctionCallOutput(Web3Exception):
     """
@@ -38,24 +76,18 @@ class BadFunctionCallOutput(Web3Exception):
     Most likely ABI mismatch.
     """
 
-    pass
-
 
 class BlockNumberOutofRange(Web3Exception):
     """
     block_identifier passed does not match known block.
     """
 
-    pass
-
 
 class ProviderConnectionError(Web3Exception):
     """
     Raised when unable to connect to a provider
     """
 
-    pass
-
 
 class CannotHandleRequest(Web3Exception):
     """
@@ -63,16 +95,12 @@ class CannotHandleRequest(Web3Exception):
     that the manager should proceed to the next provider.
     """
 
-    pass
-
 
 class TooManyRequests(Web3Exception):
     """
     Raised by a provider to signal that too many requests have been made consecutively.
     """
 
-    pass
-
 
 class MultipleFailedRequests(Web3Exception):
     """
@@ -80,16 +108,12 @@ class MultipleFailedRequests(Web3Exception):
     (or similar) data have failed.
     """
 
-    pass
-
 
 class InvalidAddress(Web3Exception):
     """
     The supplied address does not have a valid checksum, as defined in EIP-55
     """
 
-    pass
-
 
 class NameNotFound(Web3Exception):
     """
@@ -97,8 +121,6 @@ class NameNotFound(Web3Exception):
     does not resolve to an address.
     """
 
-    pass
-
 
 class StaleBlockchain(Web3Exception):
     """
@@ -128,8 +150,6 @@ class MismatchedABI(Web3Exception):
     attempt is made to access a function/event that does not exist in the ABI.
     """
 
-    pass
-
 
 class ABIEventFunctionNotFound(AttributeError, MismatchedABI):
     """
@@ -137,8 +157,6 @@ class ABIEventFunctionNotFound(AttributeError, MismatchedABI):
     that does not exist in the ABI.
     """
 
-    pass
-
 
 class ABIFunctionNotFound(AttributeError, MismatchedABI):
     """
@@ -146,56 +164,43 @@ class ABIFunctionNotFound(AttributeError, MismatchedABI):
     that does not exist in the ABI.
     """
 
-    pass
-
 
 class FallbackNotFound(Web3Exception):
     """
     Raised when fallback function doesn't exist in contract.
     """
 
-    pass
 
-
-class Web3ValidationError(Web3Exception, ValidationError):
+# type ignored because subclassing ValidationError which has type Any
+class Web3ValidationError(Web3Exception, ValidationError):  # type: ignore[misc]
     """
     Raised when a supplied value is invalid.
     """
 
-    pass
-
 
 class ExtraDataLengthError(Web3ValidationError):
     """
     Raised when an RPC call returns >32 bytes of extraData.
     """
 
-    pass
-
 
 class NoABIFunctionsFound(Web3Exception):
     """
     Raised when an ABI is present, but doesn't contain any functions.
     """
 
-    pass
-
 
 class NoABIFound(Web3Exception):
     """
     Raised when no ABI is present.
     """
 
-    pass
-
 
 class NoABIEventsFound(Web3Exception):
     """
     Raised when an ABI doesn't contain any events.
     """
 
-    pass
-
 
 class InsufficientData(Web3Exception):
     """
@@ -203,8 +208,6 @@ class InsufficientData(Web3Exception):
     complete a calculation
     """
 
-    pass
-
 
 class TimeExhausted(Web3Exception):
     """
@@ -212,16 +215,12 @@ class TimeExhausted(Web3Exception):
     result within a specified timeout.
     """
 
-    pass
-
 
 class TransactionNotFound(Web3Exception):
     """
     Raised when a tx hash used to lookup a tx in a jsonrpc call cannot be found.
     """
 
-    pass
-
 
 class TransactionIndexingInProgress(Web3Exception):
     """
@@ -229,40 +228,30 @@ class TransactionIndexingInProgress(Web3Exception):
     still being in progress.
     """
 
-    pass
-
 
 class BlockNotFound(Web3Exception):
     """
     Raised when the block id used to lookup a block in a jsonrpc call cannot be found.
     """
 
-    pass
-
 
 class InfuraProjectIdNotFound(Web3Exception):
     """
     Raised when there is no Infura Project Id set.
     """
 
-    pass
-
 
 class LogTopicError(Web3Exception):
     """
     Raised when the number of log topics is mismatched.
     """
 
-    pass
-
 
 class InvalidEventABI(Web3Exception):
     """
     Raised when the event ABI is invalid.
     """
 
-    pass
-
 
 class ContractLogicError(Web3Exception):
     """
@@ -274,6 +263,7 @@ class ContractLogicError(Web3Exception):
         message: Optional[str] = None,
         data: Optional[Union[str, Dict[str, str]]] = None,
     ):
+        super().__init__(message, data)
         self.message = message
         self.data = data
 
@@ -283,16 +273,12 @@ class ContractCustomError(ContractLogicError):
     Raised on a contract revert custom error
     """
 
-    pass
-
 
 class ContractPanicError(ContractLogicError):
     """
     Raised when a contract reverts with Panic, as of Solidity 0.8.0
     """
 
-    pass
-
 
 class OffchainLookup(ContractLogicError):
     """
@@ -330,12 +316,8 @@ class BadResponseFormat(Web3Exception):
     Raised when a JSON-RPC response comes back in an unexpected format
     """
 
-    pass
-
 
 class MethodUnavailable(Web3Exception):
     """
     Raised when the method is not available on the node
     """
-
-    pass

web3/gas_strategies/time_based.py

@@ -84,8 +84,7 @@ def _get_raw_miner_data(
     latest = w3.eth.get_block("latest", full_transactions=True)
 
     for transaction in latest["transactions"]:
-        # type ignored b/c actual transaction is TxData not HexBytes
-        yield (latest["miner"], latest["hash"], transaction["gasPrice"])  # type: ignore
+        yield (latest["miner"], latest["hash"], transaction["gasPrice"])
 
     block = latest
 
@@ -97,8 +96,7 @@ def _get_raw_miner_data(
         # block numbers to make caching the data easier to implement.
         block = w3.eth.get_block(block["parentHash"], full_transactions=True)
         for transaction in block["transactions"]:
-            # type ignored b/c actual transaction is TxData not HexBytes
-            yield (block["miner"], block["hash"], transaction["gasPrice"])  # type: ignore  # noqa: E501
+            yield (block["miner"], block["hash"], transaction["gasPrice"])
 
 
 def _aggregate_miner_data(

web3/geth.py

@@ -5,6 +5,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Protocol,
     Tuple,
 )
 
@@ -18,9 +19,6 @@ from hexbytes.main import (
     HexBytes,
 )
 
-from web3._utils.compat import (
-    Protocol,
-)
 from web3._utils.rpc_abi import (
     RPC,
 )

web3/main.py

@@ -84,6 +84,10 @@ from web3.eth import (
     AsyncEth,
     Eth,
 )
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from web3.geth import (
     AsyncGeth,
     AsyncGethAdmin,
@@ -283,7 +287,7 @@ class BaseWeb3:
             input_bytes = to_bytes(primitive, hexstr=hexstr, text=text)
             return eth_utils_keccak(input_bytes)
 
-        raise TypeError(
+        raise Web3TypeError(
             f"You called keccak with first arg {primitive!r} and keywords "
             f"{{'text': {text!r}, 'hexstr': {hexstr!r}}}. You must call it with "
             "one of these approaches: keccak(text='txt'), keccak(hexstr='0x747874'), "
@@ -304,7 +308,7 @@ class BaseWeb3:
         and list of corresponding values  -- `[20, [-1, 5, 0], True]`
         """
         if len(abi_types) != len(values):
-            raise ValueError(
+            raise Web3ValueError(
                 "Length mismatch between provided abi types and values.  Got "
                 f"{len(abi_types)} types and {len(values)} values."
             )

web3/manager.py

@@ -1,4 +1,3 @@
-import asyncio
 import logging
 from typing import (
     TYPE_CHECKING,
@@ -36,6 +35,8 @@ from web3.exceptions import (
     BadResponseFormat,
     MethodUnavailable,
     ProviderConnectionError,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.middleware import (
     AttributeDictMiddleware,
@@ -239,14 +240,18 @@ class RequestManager:
             error = response.get("error")
             # Raise the error when the value is a string
             if error is None or isinstance(error, str):
-                raise ValueError(error)
+                raise Web3ValueError(error)
 
             # Errors must include an integer code
             code = error.get("code")
             if not isinstance(code, int):
                 _raise_bad_response_format(response, "error['code'] must be an integer")
             elif code == METHOD_NOT_FOUND:
-                raise MethodUnavailable(error)
+                raise MethodUnavailable(
+                    error,
+                    user_message="Check your node provider's API docs to see what "
+                    "methods are supported",
+                )
 
             # Errors must include a message
             if not isinstance(error.get("message"), str):
@@ -256,7 +261,7 @@ class RequestManager:
 
             apply_error_formatters(error_formatters, response)
 
-            raise ValueError(error)
+            raise Web3ValueError(error)
 
         # Format and validate results
         elif "result" in response:
@@ -320,8 +325,8 @@ class RequestManager:
             cast("AsyncWeb3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
         self.logger.debug(
-            "Making request to open socket connection - "
-            f"uri: {provider.endpoint_uri}, method: {method}"
+            "Making request to open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
         )
         response = await request_func(method, params)
         return await self._process_response(response)
@@ -334,7 +339,7 @@ class RequestManager:
 
     async def _message_stream(self) -> AsyncGenerator[RPCResponse, None]:
         if not isinstance(self._provider, PersistentConnectionProvider):
-            raise TypeError(
+            raise Web3TypeError(
                 "Only providers that maintain an open, persistent connection "
                 "can listen to streams."
             )
@@ -345,11 +350,7 @@ class RequestManager:
             )
 
         while True:
-            # sleep(0) here seems to be the most efficient way to yield control
-            # back to the event loop while waiting for the response in the queue.
-            await asyncio.sleep(0)
-
-            response = self._request_processor.pop_raw_response(subscription=True)
+            response = await self._request_processor.pop_raw_response(subscription=True)
             if (
                 response is not None
                 and response.get("params", {}).get("subscription")

web3/method.py

@@ -32,7 +32,9 @@ from web3._utils.rpc_abi import (
     RPC,
 )
 from web3.exceptions import (
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     RPCEndpoint,
@@ -66,7 +68,9 @@ def _set_mungers(
     return (
         mungers
         if mungers
-        else [default_munger] if is_property else [default_root_munger]
+        else [default_munger]
+        if is_property
+        else [default_root_munger]
     )
 
 
@@ -84,7 +88,8 @@ TFunc = TypeVar("TFunc", bound=Callable[..., Any])
 
 
 class Method(Generic[TFunc]):
-    """Method object for web3 module methods
+    """
+    Method object for web3 module methods
 
     Calls to the Method go through these steps:
 
@@ -147,7 +152,7 @@ class Method(Generic[TFunc]):
         self, obj: Optional["Module"] = None, obj_type: Optional[Type["Module"]] = None
     ) -> TFunc:
         if obj is None:
-            raise TypeError(
+            raise Web3TypeError(
                 "Direct calls to methods are not supported. "
                 "Methods must be called from an module instance, "
                 "usually attached to a web3 instance."
@@ -163,7 +168,7 @@ class Method(Generic[TFunc]):
             return self.json_rpc_method
         elif isinstance(self.json_rpc_method, (str,)):
             return lambda *_: self.json_rpc_method
-        raise ValueError(
+        raise Web3ValueError(
             "``json_rpc_method`` config invalid.  May be a string or function"
         )
 
@@ -175,7 +180,9 @@ class Method(Generic[TFunc]):
             lambda args, munger: munger(module, *args, **kwargs), self.mungers, args
         )
 
-    def process_params(self, module: "Module", *args: Any, **kwargs: Any) -> Tuple[
+    def process_params(
+        self, module: "Module", *args: Any, **kwargs: Any
+    ) -> Tuple[
         Tuple[Union[RPCEndpoint, Callable[..., RPCEndpoint]], Tuple[Any, ...]],
         Tuple[
             Union[TReturn, Dict[str, Callable[..., Any]]],
@@ -226,5 +233,6 @@ class DeprecatedMethod:
         warnings.warn(
             f"{self.old_name} is deprecated in favor of {self.new_name}",
             category=DeprecationWarning,
+            stacklevel=2,
         )
         return self.method.__get__(obj, obj_type)

web3/middleware/base.py

@@ -48,7 +48,9 @@ class Web3Middleware:
     def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
         return method, params
 
-    def response_processor(self, method: "RPCEndpoint", response: "RPCResponse") -> Any:
+    def response_processor(
+        self, method: "RPCEndpoint", response: "RPCResponse"
+    ) -> "RPCResponse":
         return response
 
     # -- async -- #
@@ -76,7 +78,7 @@ class Web3Middleware:
         self,
         method: "RPCEndpoint",
         response: "RPCResponse",
-    ) -> Any:
+    ) -> "RPCResponse":
         return response
 
 

web3/middleware/filter.py

@@ -42,6 +42,9 @@ from web3._utils.formatters import (
 from web3._utils.rpc_abi import (
     RPC,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.middleware.base import (
     Web3Middleware,
 )
@@ -71,7 +74,8 @@ else:
 
 
 def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, int]]:
-    """Creates a segment counting generator
+    """
+    Creates a segment counting generator
 
     The generator returns tuple pairs of integers
     that correspond to segments in the provided range.
@@ -84,6 +88,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
 
 
     Example:
+    -------
 
     >>> segment_counter = segment_count(start=0, stop=10, step=3)
     >>> next(segment_counter)
@@ -94,6 +99,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
     (6, 9)
     >>> next(segment_counter) #  Remainder is also returned
     (9, 10)
+
     """
     return gen_bounded_segments(start, stop, step)
 
@@ -104,10 +110,9 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
     if start + step >= stop:
         yield (start, stop)
         return
-    for segment in zip(
+    yield from zip(
         range(start, stop - step + 1, step), range(start + step, stop + 1, step)
-    ):
-        yield segment
+    )
 
     remainder = (stop - start) % step
     #  Handle the remainder
@@ -118,13 +123,14 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
 def block_ranges(
     start_block: BlockNumber, last_block: Optional[BlockNumber], step: int = 5
 ) -> Iterable[Tuple[BlockNumber, BlockNumber]]:
-    """Returns 2-tuple ranges describing ranges of block from start_block to last_block
+    """
+    Returns 2-tuple ranges describing ranges of block from start_block to last_block
 
     Ranges do not overlap to facilitate use as ``toBlock``, ``fromBlock``
     json-rpc arguments, which are both inclusive.
     """
     if last_block is not None and start_block > last_block:
-        raise TypeError(
+        raise Web3TypeError(
             "Incompatible start and stop arguments.",
             "Start must be less than or equal to stop.",
         )
@@ -138,7 +144,8 @@ def block_ranges(
 def iter_latest_block(
     w3: "Web3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> Iterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -160,8 +167,7 @@ def iter_latest_block(
 
     while True:
         latest_block = w3.eth.block_number
-        # type ignored b/c is_bounded_range prevents unsupported comparison
-        if is_bounded_range and latest_block > to_block:  # type: ignore
+        if is_bounded_range and latest_block > to_block:
             yield None
         #  No new blocks since last iteration.
         if _last is not None and _last == latest_block:
@@ -176,7 +182,8 @@ def iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> Iterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `fromBlock` to the latest mined block,
     until reaching toBlock. e.g.:
@@ -212,7 +219,8 @@ def get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> Iterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.
@@ -247,9 +255,8 @@ class RequestLogs:
         if from_block is None or from_block == "latest":
             self._from_block = BlockNumber(w3.eth.block_number + 1)
         elif is_string(from_block) and is_hex(from_block):
-            self._from_block = BlockNumber(hex_to_integer(from_block))  # type: ignore
+            self._from_block = BlockNumber(hex_to_integer(from_block))
         else:
-            # cast b/c LatestBlockParam is handled above
             self._from_block = from_block
         self._to_block = to_block
         self.filter_changes = self._get_filter_changes()
@@ -265,7 +272,7 @@ class RequestLogs:
         elif self._to_block == "latest":
             to_block = self.w3.eth.block_number
         elif is_string(self._to_block) and is_hex(self._to_block):
-            to_block = BlockNumber(hex_to_integer(self._to_block))  # type: ignore
+            to_block = BlockNumber(hex_to_integer(self._to_block))
         else:
             to_block = self._to_block
 
@@ -352,7 +359,8 @@ def block_hashes_in_range(
 async def async_iter_latest_block(
     w3: "AsyncWeb3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> AsyncIterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -390,7 +398,8 @@ async def async_iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> AsyncIterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `from_block` to the latest mined block,
     until reaching to_block. e.g.:
@@ -423,7 +432,8 @@ async def async_get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> AsyncIterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.