Add Black linting to web3/providers (#2522)

* Run black against web3/providers

* Add newsfragment

Author: kclowes

newsfragments/2522.misc.rst

@@ -0,0 +1 @@
+Add Black linting to ``web3/providers`` directory

tox.ini

@@ -64,7 +64,7 @@ basepython=python
 extras=linter
 commands=
     flake8 {toxinidir}/web3 {toxinidir}/ens {toxinidir}/ethpm {toxinidir}/tests --exclude {toxinidir}/ethpm/ethpm-spec
-    black {toxinidir}/ethpm {toxinidir}/web3/auto {toxinidir}/web3/utils {toxinidir}/web3/_utils {toxinidir}/web3/beacon {toxinidir}/web3/gas_strategies {toxinidir}/web3/scripts --exclude {toxinidir}/ethpm/ethpm-spec --check
+    black {toxinidir}/ethpm {toxinidir}/web3/auto {toxinidir}/web3/utils {toxinidir}/web3/_utils {toxinidir}/web3/beacon {toxinidir}/web3/gas_strategies {toxinidir}/web3/scripts {toxinidir}/web3/providers --exclude {toxinidir}/ethpm/ethpm-spec --check
     isort --recursive --check-only --diff {toxinidir}/web3/ {toxinidir}/ens/ {toxinidir}/ethpm/ {toxinidir}/tests/
     mypy -p web3 -p ethpm -p ens --config-file {toxinidir}/mypy.ini
 

web3/providers/async_base.py

@@ -34,24 +34,26 @@
 class AsyncBaseProvider:
     _middlewares: Tuple[Middleware, ...] = ()
     # a tuple of (all_middlewares, request_func)
-    _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (None, None)
+    _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (
+        None,
+        None,
+    )
 
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
 
     def __init__(self) -> None:
         warnings.warn(
             "Async providers are still being developed and refined. "
-            "Expect breaking changes in minor releases.")
+            "Expect breaking changes in minor releases."
+        )
 
     @property
     def middlewares(self) -> Tuple[Middleware, ...]:
         return self._middlewares
 
     @middlewares.setter
-    def middlewares(
-        self, values: MiddlewareOnion
-    ) -> None:
+    def middlewares(self, values: MiddlewareOnion) -> None:
         # tuple(values) converts to MiddlewareOnion -> Tuple[Middleware, ...]
         self._middlewares = tuple(values)  # type: ignore
 
@@ -64,7 +66,7 @@ async def request_func(
         if cache_key is None or cache_key != all_middlewares:
             self._request_func_cache = (
                 all_middlewares,
-                await self._generate_request_func(w3, all_middlewares)
+                await self._generate_request_func(w3, all_middlewares),
             )
         return self._request_func_cache[-1]
 
@@ -104,11 +106,11 @@ def decode_rpc_response(self, raw_response: bytes) -> RPCResponse:
 
     async def isConnected(self) -> bool:
         try:
-            response = await self.make_request(RPCEndpoint('web3_clientVersion'), [])
+            response = await self.make_request(RPCEndpoint("web3_clientVersion"), [])
         except OSError:
             return False
 
-        assert response['jsonrpc'] == '2.0'
-        assert 'error' not in response
+        assert response["jsonrpc"] == "2.0"
+        assert "error" not in response
 
         return True

web3/providers/async_rpc.py

@@ -42,8 +42,9 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
     _request_kwargs = None
 
     def __init__(
-        self, endpoint_uri: Optional[Union[URI, str]] = None,
-            request_kwargs: Optional[Any] = None
+        self,
+        endpoint_uri: Optional[Union[URI, str]] = None,
+        request_kwargs: Optional[Any] = None,
     ) -> None:
         if endpoint_uri is None:
             self.endpoint_uri = get_default_http_endpoint()
@@ -62,26 +63,28 @@ def __str__(self) -> str:
 
     @to_dict
     def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
-        if 'headers' not in self._request_kwargs:
-            yield 'headers', self.get_request_headers()
+        if "headers" not in self._request_kwargs:
+            yield "headers", self.get_request_headers()
         for key, value in self._request_kwargs.items():
             yield key, value
 
     def get_request_headers(self) -> Dict[str, str]:
         return {
-            'Content-Type': 'application/json',
-            'User-Agent': construct_user_agent(str(type(self))),
+            "Content-Type": "application/json",
+            "User-Agent": construct_user_agent(str(type(self))),
         }
 
     async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        self.logger.debug(f"Making request HTTP. URI: {self.endpoint_uri}, Method: {method}")
+        self.logger.debug(
+            f"Making request HTTP. URI: {self.endpoint_uri}, Method: {method}"
+        )
         request_data = self.encode_rpc_request(method, params)
         raw_response = await async_make_post_request(
-            self.endpoint_uri,
-            request_data,
-            **self.get_request_kwargs()
+            self.endpoint_uri, request_data, **self.get_request_kwargs()
         )
         response = self.decode_rpc_response(raw_response)
-        self.logger.debug(f"Getting response HTTP. URI: {self.endpoint_uri}, "
-                          f"Method: {method}, Response: {response}")
+        self.logger.debug(
+            f"Getting response HTTP. URI: {self.endpoint_uri}, "
+            f"Method: {method}, Response: {response}"
+        )
         return response

web3/providers/auto.py

@@ -31,12 +31,12 @@
     RPCResponse,
 )
 
-HTTP_SCHEMES = {'http', 'https'}
-WS_SCHEMES = {'ws', 'wss'}
+HTTP_SCHEMES = {"http", "https"}
+WS_SCHEMES = {"ws", "wss"}
 
 
 def load_provider_from_environment() -> BaseProvider:
-    uri_string = URI(os.environ.get('WEB3_PROVIDER_URI', ''))
+    uri_string = URI(os.environ.get("WEB3_PROVIDER_URI", ""))
     if not uri_string:
         return None
 
@@ -47,15 +47,15 @@ def load_provider_from_uri(
     uri_string: URI, headers: Optional[Dict[str, Tuple[str, str]]] = None
 ) -> BaseProvider:
     uri = urlparse(uri_string)
-    if uri.scheme == 'file':
+    if uri.scheme == "file":
         return IPCProvider(uri.path)
     elif uri.scheme in HTTP_SCHEMES:
         return HTTPProvider(uri_string, headers)
     elif uri.scheme in WS_SCHEMES:
         return WebsocketProvider(uri_string)
     else:
         raise NotImplementedError(
-            f'Web3 does not know how to connect to scheme {uri.scheme!r} in {uri_string!r}'
+            f"Web3 does not know how to connect to scheme {uri.scheme!r} in {uri_string!r}"
         )
 
 
@@ -71,8 +71,9 @@ class AutoProvider(BaseProvider):
 
     def __init__(
         self,
-        potential_providers: Optional[Sequence[Union[Callable[..., BaseProvider],
-                                      Type[BaseProvider]]]] = None
+        potential_providers: Optional[
+            Sequence[Union[Callable[..., BaseProvider], Type[BaseProvider]]]
+        ] = None,
     ) -> None:
         """
         :param iterable potential_providers: ordered series of provider classes to attempt with
@@ -96,8 +97,9 @@ def isConnected(self) -> bool:
         provider = self._get_active_provider(use_cache=True)
         return provider is not None and provider.isConnected()
 
-    def _proxy_request(self, method: RPCEndpoint, params: Any,
-                       use_cache: bool = True) -> RPCResponse:
+    def _proxy_request(
+        self, method: RPCEndpoint, params: Any, use_cache: bool = True
+    ) -> RPCResponse:
         provider = self._get_active_provider(use_cache)
         if provider is None:
             raise CannotHandleRequest(

web3/providers/base.py

@@ -33,7 +33,10 @@
 class BaseProvider:
     _middlewares: Tuple[Middleware, ...] = ()
     # a tuple of (all_middlewares, request_func)
-    _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (None, None)
+    _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (
+        None,
+        None,
+    )
 
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
@@ -43,9 +46,7 @@ def middlewares(self) -> Tuple[Middleware, ...]:
         return self._middlewares
 
     @middlewares.setter
-    def middlewares(
-        self, values: MiddlewareOnion
-    ) -> None:
+    def middlewares(self, values: MiddlewareOnion) -> None:
         # tuple(values) converts to MiddlewareOnion -> Tuple[Middleware, ...]
         self._middlewares = tuple(values)  # type: ignore
 
@@ -63,7 +64,7 @@ def request_func(
         if cache_key is None or cache_key != all_middlewares:
             self._request_func_cache = (
                 all_middlewares,
-                self._generate_request_func(w3, all_middlewares)
+                self._generate_request_func(w3, all_middlewares),
             )
         return self._request_func_cache[-1]
 
@@ -103,11 +104,11 @@ def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
 
     def isConnected(self) -> bool:
         try:
-            response = self.make_request(RPCEndpoint('web3_clientVersion'), [])
+            response = self.make_request(RPCEndpoint("web3_clientVersion"), [])
         except OSError:
             return False
 
-        assert response['jsonrpc'] == '2.0'
-        assert 'error' not in response
+        assert response["jsonrpc"] == "2.0"
+        assert "error" not in response
 
         return True

web3/providers/eth_tester/__init__.py

@@ -1,4 +1,3 @@
-
 from .main import (  # noqa: F401
     EthereumTesterProvider,
     AsyncEthereumTesterProvider,