Remove sql_lru_cache from sync substrate and async substrate, and instead only use it in an experimental new class for just async substrate.

Author: thewhaleking

async_substrate_interface/async_substrate.py

@@ -21,6 +21,7 @@
     TYPE_CHECKING,
 )
 
+import asyncstdlib as a
 from bittensor_wallet.keypair import Keypair
 from bittensor_wallet.utils import SS58_FORMAT
 from bt_decode import MetadataV15, PortableRegistry, decode as decode_by_type_string
@@ -1659,8 +1660,11 @@ def convert_event_data(data):
                 events.append(convert_event_data(item))
         return events
 
-    @async_sql_lru_cache(max_size=512)
+    @a.lru_cache(maxsize=512)
     async def get_parent_block_hash(self, block_hash):
+        return await self._get_parent_block_hash(block_hash)
+
+    async def _get_parent_block_hash(self, block_hash):
         block_header = await self.rpc_request("chain_getHeader", [block_hash])
 
         if block_header["result"] is None:
@@ -1672,16 +1676,22 @@ async def get_parent_block_hash(self, block_hash):
             return block_hash
         return parent_block_hash
 
-    @async_sql_lru_cache(max_size=16)
+    @a.lru_cache(maxsize=16)
     async def get_block_runtime_info(self, block_hash: str) -> dict:
+        return await self._get_block_runtime_info(block_hash)
+
+    async def _get_block_runtime_info(self, block_hash: str) -> dict:
         """
         Retrieve the runtime info of given block_hash
         """
         response = await self.rpc_request("state_getRuntimeVersion", [block_hash])
         return response.get("result")
 
-    @async_sql_lru_cache(max_size=512)
+    @a.lru_cache(maxsize=512)
     async def get_block_runtime_version_for(self, block_hash: str):
+        return await self._get_block_runtime_version_for(block_hash)
+
+    async def _get_block_runtime_version_for(self, block_hash: str):
         """
         Retrieve the runtime version of the parent of a given block_hash
         """
@@ -1914,7 +1924,6 @@ async def _make_rpc_request(
 
         return request_manager.get_results()
 
-    @async_sql_lru_cache(max_size=512)
     async def supports_rpc_method(self, name: str) -> bool:
         """
         Check if substrate RPC supports given method
@@ -1985,8 +1994,11 @@ async def rpc_request(
         else:
             raise SubstrateRequestException(result[payload_id][0])
 
-    @async_sql_lru_cache(max_size=512)
+    @a.lru_cache(maxsize=512)
     async def get_block_hash(self, block_id: int) -> str:
+        return await self._get_block_hash(block_id)
+
+    async def _get_block_hash(self, block_id: int) -> str:
         return (await self.rpc_request("chain_getBlockHash", [block_id]))["result"]
 
     async def get_chain_head(self) -> str:
@@ -3230,6 +3242,28 @@ async def _handler(block_data: dict[str, Any]):
             return await co
 
 
+class DiskCachedAsyncSubstrateInterface(AsyncSubstrateInterface):
+    """
+    Experimental new class that uses disk-caching in addition to memory-caching for the cached methods
+    """
+
+    @async_sql_lru_cache(maxsize=512)
+    async def get_parent_block_hash(self, block_hash):
+        return await self._get_parent_block_hash(block_hash)
+
+    @async_sql_lru_cache(maxsize=16)
+    async def get_block_runtime_info(self, block_hash: str) -> dict:
+        return await self._get_block_runtime_info(block_hash)
+
+    @async_sql_lru_cache(maxsize=512)
+    async def get_block_runtime_version_for(self, block_hash: str):
+        return await self._get_block_runtime_version_for(block_hash)
+
+    @async_sql_lru_cache(maxsize=512)
+    async def get_block_hash(self, block_id: int) -> str:
+        return await self._get_block_hash(block_id)
+
+
 async def get_async_substrate_interface(
     url: str,
     use_remote_preset: bool = False,

async_substrate_interface/sync_substrate.py

@@ -1,3 +1,4 @@
+import functools
 import logging
 import random
 from hashlib import blake2b
@@ -30,7 +31,6 @@
     ScaleObj,
 )
 from async_substrate_interface.utils import hex_to_bytes, json, get_next_id
-from async_substrate_interface.utils.cache import sql_lru_cache
 from async_substrate_interface.utils.decoding import (
     _determine_if_old_runtime_call,
     _bt_decode_to_dict_or_list,
@@ -1406,7 +1406,7 @@ def convert_event_data(data):
                 events.append(convert_event_data(item))
         return events
 
-    @sql_lru_cache(max_size=512)
+    @functools.lru_cache(maxsize=512)
     def get_parent_block_hash(self, block_hash):
         block_header = self.rpc_request("chain_getHeader", [block_hash])
 
@@ -1419,15 +1419,15 @@ def get_parent_block_hash(self, block_hash):
             return block_hash
         return parent_block_hash
 
-    @sql_lru_cache(max_size=16)
+    @functools.lru_cache(maxsize=16)
     def get_block_runtime_info(self, block_hash: str) -> dict:
         """
         Retrieve the runtime info of given block_hash
         """
         response = self.rpc_request("state_getRuntimeVersion", [block_hash])
         return response.get("result")
 
-    @sql_lru_cache(max_size=512)
+    @functools.lru_cache(maxsize=512)
     def get_block_runtime_version_for(self, block_hash: str):
         """
         Retrieve the runtime version of the parent of a given block_hash
@@ -1655,8 +1655,7 @@ def _make_rpc_request(
 
         return request_manager.get_results()
 
-    # TODO change this logic
-    @sql_lru_cache(max_size=512)
+    @functools.lru_cache(maxsize=512)
     def supports_rpc_method(self, name: str) -> bool:
         """
         Check if substrate RPC supports given method
@@ -1727,7 +1726,7 @@ def rpc_request(
         else:
             raise SubstrateRequestException(result[payload_id][0])
 
-    @sql_lru_cache(max_size=512)
+    @functools.lru_cache(maxsize=512)
     def get_block_hash(self, block_id: int) -> str:
         return self.rpc_request("chain_getBlockHash", [block_id])["result"]
 

async_substrate_interface/utils/cache.py

@@ -53,14 +53,14 @@ def _insert_into_cache(c, conn, table_name, key, result, chain):
         pass
 
 
-def sql_lru_cache(max_size=None):
+def sql_lru_cache(maxsize=None):
     def decorator(func):
         conn = sqlite3.connect(CACHE_LOCATION)
         c = conn.cursor()
         table_name = _get_table_name(func)
         _create_table(c, conn, table_name)
 
-        @functools.lru_cache(maxsize=max_size)
+        @functools.lru_cache(maxsize=maxsize)
         def inner(self, *args, **kwargs):
             c = conn.cursor()
             key = pickle.dumps((args, kwargs))
@@ -83,14 +83,14 @@ def inner(self, *args, **kwargs):
     return decorator
 
 
-def async_sql_lru_cache(max_size=None):
+def async_sql_lru_cache(maxsize=None):
     def decorator(func):
         conn = sqlite3.connect(CACHE_LOCATION)
         c = conn.cursor()
         table_name = _get_table_name(func)
         _create_table(c, conn, table_name)
 
-        @a.lru_cache(maxsize=max_size)
+        @a.lru_cache(maxsize=maxsize)
         async def inner(self, *args, **kwargs):
             c = conn.cursor()
             key = pickle.dumps((args, kwargs))