Better organize provider property assignment and superclass calls:

- Explicitly set instance propertiece in the constructor, rather than
  the class.
- Order property assignments in the constructor so that the superclass
  is initialized first, with explicit mention when it's useful to
  initialize a particular property on the subclass first.

Author: fselmo

web3/main.py

@@ -513,7 +513,8 @@ def ens(self, new_ens: Union[AsyncENS, "Empty"]) -> None:
 
     # -- persistent connection settings -- #
 
-    _subscription_manager: SubscriptionManager = None
+    _subscription_manager: Optional[SubscriptionManager] = None
+    _persistent_connection: Optional["PersistentConnection"] = None
 
     @property
     @persistent_connection_provider_method()
@@ -523,13 +524,14 @@ def subscription_manager(self) -> SubscriptionManager:
         """
         if not self._subscription_manager:
             self._subscription_manager = SubscriptionManager(self)
-
         return self._subscription_manager
 
     @property
     @persistent_connection_provider_method()
     def socket(self) -> PersistentConnection:
-        return PersistentConnection(self)
+        if self._persistent_connection is None:
+            self._persistent_connection = PersistentConnection(self)
+        return self._persistent_connection
 
     # w3 = await AsyncWeb3(PersistentConnectionProvider(...))
     @persistent_connection_provider_method(

web3/manager.py

@@ -292,9 +292,6 @@ def __init__(
             provider = cast(PersistentConnectionProvider, self.provider)
             self._request_processor: RequestProcessor = provider._request_processor
 
-    w3: Union["AsyncWeb3", "Web3"] = None
-    _provider = None
-
     @property
     def provider(self) -> Union["BaseProvider", "AsyncBaseProvider"]:
         return self._provider

web3/providers/async_base.py

@@ -83,10 +83,6 @@ class AsyncBaseProvider:
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
 
-    # request caching
-    _request_cache: SimpleCache
-    _request_cache_lock: asyncio.Lock = asyncio.Lock()
-
     def __init__(
         self,
         cache_allowed_requests: bool = False,
@@ -96,6 +92,8 @@ def __init__(
         ] = empty,
     ) -> None:
         self._request_cache = SimpleCache(1000)
+        self._request_cache_lock: asyncio.Lock = asyncio.Lock()
+
         self.cache_allowed_requests = cache_allowed_requests
         self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
         self.request_cache_validation_threshold = request_cache_validation_threshold
@@ -172,11 +170,9 @@ async def disconnect(self) -> None:
 
 
 class AsyncJSONBaseProvider(AsyncBaseProvider):
-    logger = logging.getLogger("web3.providers.async_base.AsyncJSONBaseProvider")
-
     def __init__(self, **kwargs: Any) -> None:
-        self.request_counter = itertools.count()
         super().__init__(**kwargs)
+        self.request_counter = itertools.count()
 
     def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
         request_id = next(self.request_counter)

web3/providers/base.py

@@ -66,10 +66,6 @@ class BaseProvider:
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
 
-    # request caching
-    _request_cache: SimpleCache
-    _request_cache_lock: threading.Lock = threading.Lock()
-
     def __init__(
         self,
         cache_allowed_requests: bool = False,
@@ -79,6 +75,8 @@ def __init__(
         ] = empty,
     ) -> None:
         self._request_cache = SimpleCache(1000)
+        self._request_cache_lock: threading.Lock = threading.Lock()
+
         self.cache_allowed_requests = cache_allowed_requests
         self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
         self.request_cache_validation_threshold = request_cache_validation_threshold
@@ -124,8 +122,8 @@ class JSONBaseProvider(BaseProvider):
     ] = (None, None)
 
     def __init__(self, **kwargs: Any) -> None:
-        self.request_counter = itertools.count()
         super().__init__(**kwargs)
+        self.request_counter = itertools.count()
 
     def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
         rpc_dict = {

web3/providers/ipc.py

@@ -146,6 +146,7 @@ def __init__(
         timeout: int = 30,
         **kwargs: Any,
     ) -> None:
+        super().__init__(**kwargs)
         if ipc_path is None:
             self.ipc_path = get_default_ipc_path()
         elif isinstance(ipc_path, str) or isinstance(ipc_path, Path):
@@ -156,7 +157,6 @@ def __init__(
         self.timeout = timeout
         self._lock = threading.Lock()
         self._socket = PersistantSocket(self.ipc_path)
-        super().__init__(**kwargs)
 
     def __str__(self) -> str:
         return f"<{self.__class__.__name__} {self.ipc_path}>"

web3/providers/legacy_websocket.py

@@ -102,6 +102,7 @@ def __init__(
         websocket_timeout: int = DEFAULT_WEBSOCKET_TIMEOUT,
         **kwargs: Any,
     ) -> None:
+        super().__init__(**kwargs)
         self.endpoint_uri = URI(endpoint_uri)
         self.websocket_timeout = websocket_timeout
         if self.endpoint_uri is None:
@@ -120,7 +121,6 @@ def __init__(
                     f"in websocket_kwargs, found: {found_restricted_keys}"
                 )
         self.conn = PersistentWebSocket(self.endpoint_uri, websocket_kwargs)
-        super().__init__(**kwargs)
 
     def __str__(self) -> str:
         return f"WS connection {self.endpoint_uri}"

web3/providers/persistent/async_ipc.py

@@ -59,15 +59,15 @@ def __init__(
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,
     ) -> None:
+        # initialize the ipc_path before calling the super constructor
         if ipc_path is None:
             self.ipc_path = get_default_ipc_path()
         elif isinstance(ipc_path, str) or isinstance(ipc_path, Path):
             self.ipc_path = str(Path(ipc_path).expanduser().resolve())
         else:
             raise Web3TypeError("ipc_path must be of type string or pathlib.Path")
-
-        self.read_buffer_limit = read_buffer_limit
         super().__init__(**kwargs)
+        self.read_buffer_limit = read_buffer_limit
 
     def __str__(self) -> str:
         return f"<{self.__class__.__name__} {self.ipc_path}>"

web3/providers/persistent/persistent.py

@@ -53,30 +53,26 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
     logger = logging.getLogger("web3.providers.PersistentConnectionProvider")
     has_persistent_connection = True
 
-    _request_processor: RequestProcessor
-    _message_listener_task: Optional["asyncio.Task[None]"] = None
-    _listen_event: asyncio.Event = asyncio.Event()
-
-    _batch_request_counter: Optional[int] = None
-
     def __init__(
         self,
         request_timeout: float = DEFAULT_PERSISTENT_CONNECTION_TIMEOUT,
         subscription_response_queue_size: int = 500,
         silence_listener_task_exceptions: bool = False,
         max_connection_retries: int = 5,
-        label: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
         self._request_processor = RequestProcessor(
             self,
             subscription_response_queue_size=subscription_response_queue_size,
         )
+        self._message_listener_task: Optional["asyncio.Task[None]"] = None
+        self._batch_request_counter: Optional[int] = None
+        self._listen_event: asyncio.Event = asyncio.Event()
+        self._max_connection_retries = max_connection_retries
+
         self.request_timeout = request_timeout
         self.silence_listener_task_exceptions = silence_listener_task_exceptions
-        self._max_connection_retries = max_connection_retries
-        self.label = label or self.get_endpoint_uri_or_ipc_path()
 
     def get_endpoint_uri_or_ipc_path(self) -> str:
         if hasattr(self, "endpoint_uri"):

web3/providers/persistent/websocket.py

@@ -59,18 +59,19 @@ class WebSocketProvider(PersistentConnectionProvider):
     logger = logging.getLogger("web3.providers.WebSocketProvider")
     is_async: bool = True
 
-    _ws: Optional[WebSocketClientProtocol] = None
-
     def __init__(
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
         websocket_kwargs: Optional[Dict[str, Any]] = None,
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,
     ) -> None:
+        # initialize the endpoint_uri before calling the super constructor
         self.endpoint_uri = (
             URI(endpoint_uri) if endpoint_uri is not None else get_default_endpoint()
         )
+        super().__init__(**kwargs)
+        self._ws: Optional[WebSocketClientProtocol] = None
 
         if not any(
             self.endpoint_uri.startswith(prefix)
@@ -93,8 +94,6 @@ def __init__(
 
         self.websocket_kwargs = merge(DEFAULT_WEBSOCKET_KWARGS, websocket_kwargs or {})
 
-        super().__init__(**kwargs)
-
     def __str__(self) -> str:
         return f"WebSocket connection: {self.endpoint_uri}"
 

web3/providers/rpc/rpc.py

@@ -71,6 +71,7 @@ def __init__(
         ] = empty,
         **kwargs: Any,
     ) -> None:
+        super().__init__(**kwargs)
         self._request_session_manager = HTTPSessionManager()
 
         if endpoint_uri is None:
@@ -88,8 +89,6 @@ def __init__(
                 self.endpoint_uri, session
             )
 
-        super().__init__(**kwargs)
-
     def __str__(self) -> str:
         return f"RPC connection {self.endpoint_uri}"