web3 7.0.0b7__py3-none-any.whl → 7.0.0b9__py3-none-any.whl

web3/providers/persistent/websocket.py

@@ -5,11 +5,8 @@ import os
 from typing import (
     Any,
     Dict,
-    List,
     Optional,
-    Tuple,
     Union,
-    cast,
 )
 
 from eth_typing import (
@@ -25,17 +22,12 @@ from websockets.client import (
     connect,
 )
 from websockets.exceptions import (
+    ConnectionClosedOK,
     WebSocketException,
 )
 
-from web3._utils.batching import (
-    BATCH_REQUEST_ID,
-    sort_batch_response_by_response_ids,
-)
-from web3._utils.caching import (
-    async_handle_request_caching,
-)
 from web3.exceptions import (
+    PersistentConnectionClosedOK,
     ProviderConnectionError,
     Web3ValidationError,
 )
@@ -43,7 +35,6 @@ from web3.providers.persistent import (
     PersistentConnectionProvider,
 )
 from web3.types import (
-    RPCEndpoint,
     RPCResponse,
 )
 
@@ -122,18 +113,7 @@ class WebSocketProvider(PersistentConnectionProvider):
                 ) from e
             return False
 
-    async def _provider_specific_connect(self) -> None:
-        self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
-
-    async def _provider_specific_disconnect(self) -> None:
-        if self._ws is not None and not self._ws.closed:
-            await self._ws.close()
-            self._ws = None
-
-    @async_handle_request_caching
-    async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        request_data = self.encode_rpc_request(method, params)
-
+    async def socket_send(self, request_data: bytes) -> None:
         if self._ws is None:
             raise ProviderConnectionError(
                 "Connection to websocket has not been initiated for the provider."
@@ -143,44 +123,24 @@ class WebSocketProvider(PersistentConnectionProvider):
             self._ws.send(request_data), timeout=self.request_timeout
         )
 
-        current_request_id = json.loads(request_data)["id"]
-        response = await self._get_response_for_request_id(current_request_id)
-
-        return response
+    async def socket_recv(self) -> RPCResponse:
+        raw_response = await self._ws.recv()
+        return json.loads(raw_response)
 
-    async def make_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
-        request_data = self.encode_batch_rpc_request(requests)
+    # -- private methods -- #
 
-        if self._ws is None:
-            raise ProviderConnectionError(
-                "Connection to websocket has not been initiated for the provider."
-            )
-
-        await asyncio.wait_for(
-            self._ws.send(request_data), timeout=self.request_timeout
-        )
-
-        response = cast(
-            List[RPCResponse],
-            await self._get_response_for_request_id(BATCH_REQUEST_ID),
-        )
-        return response
-
-    async def _provider_specific_message_listener(self) -> None:
-        async for raw_message in self._ws:
-            await asyncio.sleep(0)
+    async def _provider_specific_connect(self) -> None:
+        self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
 
-            response = json.loads(raw_message)
-            if isinstance(response, list):
-                response = sort_batch_response_by_response_ids(response)
+    async def _provider_specific_disconnect(self) -> None:
+        if self._ws is not None and not self._ws.closed:
+            await self._ws.close()
+            self._ws = None
 
-            subscription = (
-                response.get("method") == "eth_subscription"
-                if not isinstance(response, list)
-                else False
-            )
-            await self._request_processor.cache_raw_response(
-                response, subscription=subscription
+    async def _provider_specific_socket_reader(self) -> RPCResponse:
+        try:
+            return await self.socket_recv()
+        except ConnectionClosedOK:
+            raise PersistentConnectionClosedOK(
+                user_message="WebSocket connection received `ConnectionClosedOK`."
             )

web3/types.py

@@ -27,13 +27,13 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.compat import (
-    NotRequired,
-)
-from web3._utils.function_identifiers import (
+from web3._utils.abi_element_identifiers import (
     FallbackFn,
     ReceiveFn,
 )
+from web3._utils.compat import (
+    NotRequired,
+)
 
 if TYPE_CHECKING:
     from web3.contract.async_contract import AsyncContractFunction  # noqa: F401
@@ -53,7 +53,7 @@ BlockParams = Literal["latest", "earliest", "pending", "safe", "finalized"]
 BlockIdentifier = Union[BlockParams, BlockNumber, Hash32, HexStr, HexBytes, int]
 LatestBlockParam = Literal["latest"]
 
-FunctionIdentifier = Union[str, Type[FallbackFn], Type[ReceiveFn]]
+ABIElementIdentifier = Union[str, Type[FallbackFn], Type[ReceiveFn]]
 
 # bytes, hexbytes, or hexstr representing a 32 byte hash
 _Hash32 = Union[Hash32, HexBytes, HexStr]
@@ -75,46 +75,6 @@ class AccessListEntry(TypedDict):
 AccessList = NewType("AccessList", Sequence[AccessListEntry])
 
 
-# todo: move these to eth_typing once web3 is type hinted
-class ABIEventParams(TypedDict, total=False):
-    indexed: bool
-    name: str
-    type: str
-
-
-class ABIEvent(TypedDict, total=False):
-    anonymous: bool
-    inputs: Sequence["ABIEventParams"]
-    name: str
-    type: Literal["event"]
-
-
-class ABIFunctionComponents(TypedDict, total=False):
-    components: Sequence["ABIFunctionComponents"]
-    name: str
-    type: str
-
-
-class ABIFunctionParams(TypedDict, total=False):
-    components: Sequence["ABIFunctionComponents"]
-    name: str
-    type: str
-
-
-class ABIFunction(TypedDict, total=False):
-    constant: bool
-    inputs: Sequence["ABIFunctionParams"]
-    name: str
-    outputs: Sequence["ABIFunctionParams"]
-    payable: bool
-    stateMutability: Literal["pure", "view", "nonpayable", "payable"]
-    type: Literal["function", "constructor", "fallback", "receive"]
-
-
-ABIElement = Union[ABIFunction, ABIEvent]
-ABI = Sequence[Union[ABIFunction, ABIEvent]]
-
-
 class EventData(TypedDict):
     address: ChecksumAddress
     args: Dict[str, Any]

web3/utils/__init__.py

@@ -3,11 +3,35 @@ NOTE: This is a public utility module. Any changes to these utility methods woul
 classify as breaking changes.
 """
 
-from .abi import (
+from eth_utils.abi import (
+    abi_to_signature,
+    collapse_if_tuple,
+    event_abi_to_log_topic,
+    event_signature_to_log_topic,
+    filter_abi_by_name,
+    filter_abi_by_type,
+    function_abi_to_4byte_selector,
+    function_signature_to_4byte_selector,
     get_abi_input_names,
+    get_abi_input_types,
     get_abi_output_names,
+    get_abi_output_types,
+    get_aligned_abi_inputs,
+    get_all_event_abis,
+    get_all_function_abis,
+    get_normalized_abi_inputs,
+)
+from .abi import (  # NOQA
+    check_if_arguments_can_be_encoded,
+    get_abi_element_info,
+    get_abi_element,
+    get_event_abi,
+    get_event_log_topics,
+    log_topic_to_bytes,
+)
+from .address import (
+    get_create_address,
 )
-from .address import get_create_address
 from .async_exception_handling import (
     async_handle_offchain_lookup,
 )
@@ -19,10 +43,30 @@ from .exception_handling import (
 )
 
 __all__ = [
-    "SimpleCache",
-    "async_handle_offchain_lookup",
+    "abi_to_signature",
+    "collapse_if_tuple",
+    "event_abi_to_log_topic",
+    "event_signature_to_log_topic",
+    "filter_abi_by_name",
+    "filter_abi_by_type",
+    "function_abi_to_4byte_selector",
+    "function_signature_to_4byte_selector",
     "get_abi_input_names",
+    "get_abi_input_types",
     "get_abi_output_names",
+    "get_abi_output_types",
+    "get_aligned_abi_inputs",
+    "get_all_event_abis",
+    "get_all_function_abis",
+    "get_normalized_abi_inputs",
+    "check_if_arguments_can_be_encoded",
+    "get_abi_element_info",
+    "get_abi_element",
+    "get_event_abi",
+    "get_event_log_topics",
+    "log_topic_to_bytes",
     "get_create_address",
+    "async_handle_offchain_lookup",
+    "SimpleCache",
     "handle_offchain_lookup",
 ]