Formatting

Author: thewhaleking

async_substrate_interface/async_substrate.py

@@ -5,7 +5,6 @@
 """
 
 import asyncio
-from concurrent.futures import ProcessPoolExecutor
 import inspect
 import logging
 import random
@@ -57,10 +56,14 @@
 )
 from async_substrate_interface.utils.storage import StorageKey
 from async_substrate_interface.type_registry import _TYPE_REGISTRY
-from async_substrate_interface.utils.decoding_attempt import _decode_query_map, _decode_scale_with_runtime
+from async_substrate_interface.utils.decoding_attempt import (
+    decode_query_map,
+    _decode_scale_with_runtime,
+)
 
 if TYPE_CHECKING:
     from websockets.asyncio.client import ClientConnection
+    from concurrent.futures import ProcessPoolExecutor
 
 ResultHandler = Callable[[dict, Any], Awaitable[tuple[dict, bool]]]
 
@@ -415,7 +418,7 @@ def __init__(
         last_key: Optional[str] = None,
         max_results: Optional[int] = None,
         ignore_decoding_errors: bool = False,
-        executor: Optional["ProcessPoolExecutor"] = None
+        executor: Optional["ProcessPoolExecutor"] = None,
     ):
         self.records = records
         self.page_size = page_size
@@ -441,7 +444,7 @@ async def retrieve_next_page(self, start_key) -> list:
             start_key=start_key,
             max_results=self.max_results,
             ignore_decoding_errors=self.ignore_decoding_errors,
-            executor=self.executor
+            executor=self.executor,
         )
         if len(result.records) < self.page_size:
             self.loading_complete = True
@@ -867,7 +870,6 @@ async def encode_scale(
         await self._wait_for_registry(_attempt, _retries)
         return self._encode_scale(type_string, value)
 
-
     async def decode_scale(
         self,
         type_string: str,
@@ -2865,7 +2867,7 @@ async def query_map(
         page_size: int = 100,
         ignore_decoding_errors: bool = False,
         reuse_block_hash: bool = False,
-        executor: Optional["ProcessPoolExecutor"] = None
+        executor: Optional["ProcessPoolExecutor"] = None,
     ) -> AsyncQueryMapResult:
         """
         Iterates over all key-pairs located at the given module and storage_function. The storage
@@ -2982,13 +2984,15 @@ async def query_map(
                     # )
                     result = await asyncio.get_running_loop().run_in_executor(
                         executor,
-                        _decode_query_map,
+                        decode_query_map,
                         result_group["changes"],
                         prefix,
                         runtime.registry.registry,
                         param_types,
                         params,
-                        value_type, key_hashers, ignore_decoding_errors
+                        value_type,
+                        key_hashers,
+                        ignore_decoding_errors,
                     )
                     # max_workers = executor._max_workers
                     # result_group_changes_groups = [result_group["changes"][i:i + max_workers] for i in range(0, len(result_group["changes"]), max_workers)]
@@ -3006,13 +3010,15 @@ async def query_map(
                     # for r in all_results:
                     #     result.extend(r)
                 else:
-                    result = _decode_query_map(
+                    result = decode_query_map(
                         result_group["changes"],
                         prefix,
                         runtime.registry.registry,
                         param_types,
                         params,
-                        value_type, key_hashers, ignore_decoding_errors
+                        value_type,
+                        key_hashers,
+                        ignore_decoding_errors,
                     )
         return AsyncQueryMapResult(
             records=result,
@@ -3025,7 +3031,7 @@ async def query_map(
             last_key=last_key,
             max_results=max_results,
             ignore_decoding_errors=ignore_decoding_errors,
-            executor=executor
+            executor=executor,
         )
 
     async def submit_extrinsic(

async_substrate_interface/utils/decoding_attempt.py

@@ -9,11 +9,12 @@ class ScaleObj:
     def __init__(self, value):
         self.value = value
 
+
 def _decode_scale_with_runtime(
-        type_string: str,
-        scale_bytes: bytes,
-        runtime_registry: "Runtime",
-        return_scale_obj: bool = False
+    type_string: str,
+    scale_bytes: bytes,
+    runtime_registry: "Runtime",
+    return_scale_obj: bool = False,
 ):
     if scale_bytes == b"":
         return None
@@ -27,8 +28,17 @@ def _decode_scale_with_runtime(
     else:
         return obj
 
-def _decode_query_map(result_group_changes, prefix, runtime_registry,
-                      param_types, params, value_type, key_hashers, ignore_decoding_errors):
+
+def decode_query_map(
+    result_group_changes,
+    prefix,
+    runtime_registry,
+    param_types,
+    params,
+    value_type,
+    key_hashers,
+    ignore_decoding_errors,
+):
     def concat_hash_len(key_hasher: str) -> int:
         """
         Helper function to avoid if statements
@@ -51,16 +61,14 @@ def concat_hash_len(key_hasher: str) -> int:
             # Determine type string
             key_type_string = []
             for n in range(len(params), len(param_types)):
-                key_type_string.append(
-                    f"[u8; {concat_hash_len(key_hashers[n])}]"
-                )
+                key_type_string.append(f"[u8; {concat_hash_len(key_hashers[n])}]")
                 key_type_string.append(param_types[n])
 
             item_key_obj = _decode_scale_with_runtime(
                 f"({', '.join(key_type_string)})",
-                bytes.fromhex(item[0][len(prefix):]),
+                bytes.fromhex(item[0][len(prefix) :]),
                 runtime_registry,
-                False
+                False,
             )
 
             # strip key_hashers to use as item key
@@ -81,10 +89,7 @@ def concat_hash_len(key_hasher: str) -> int:
             item_bytes = hex_to_bytes_(item[1])
 
             item_value = _decode_scale_with_runtime(
-                value_type,
-                item_bytes,
-                runtime_registry,
-                True
+                value_type, item_bytes, runtime_registry, True
             )
 
         except Exception as _: