chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/data_layer/data_store.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import contextlib
 import logging
 from collections import defaultdict
+from collections.abc import AsyncIterator, Awaitable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, replace
 from pathlib import Path
-from typing import Any, AsyncIterator, Awaitable, BinaryIO, Callable, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, BinaryIO, Callable, Optional, Union
 
 import aiosqlite
 
@@ -495,15 +496,14 @@ class DataStore:
 
     async def check(self) -> None:
         for check in self._checks:
-            # pylint seems to think these are bound methods not unbound methods.
-            await check(self)  # pylint: disable=too-many-function-args
+            await check(self)
 
     async def _check_roots_are_incrementing(self) -> None:
         async with self.db_wrapper.reader() as reader:
             cursor = await reader.execute("SELECT * FROM root ORDER BY tree_id, generation")
             roots = [Root.from_row(row=row) async for row in cursor]
 
-            roots_by_tree: Dict[bytes32, List[Root]] = defaultdict(list)
+            roots_by_tree: dict[bytes32, list[Root]] = defaultdict(list)
             for root in roots:
                 roots_by_tree[root.store_id].append(root)
 
@@ -522,7 +522,7 @@ class DataStore:
         async with self.db_wrapper.reader() as reader:
             cursor = await reader.execute("SELECT * FROM node")
 
-            bad_node_hashes: List[bytes32] = []
+            bad_node_hashes: list[bytes32] = []
             async for row in cursor:
                 node = row_to_node(row=row)
                 if isinstance(node, InternalNode):
@@ -538,7 +538,7 @@ class DataStore:
         if len(bad_node_hashes) > 0:
             raise NodeHashError(node_hashes=bad_node_hashes)
 
-    _checks: Tuple[Callable[[DataStore], Awaitable[None]], ...] = (
+    _checks: tuple[Callable[[DataStore], Awaitable[None]], ...] = (
         _check_roots_are_incrementing,
         _check_hashes,
     )
@@ -553,7 +553,7 @@ class DataStore:
 
         return tree_root.node_hash is None
 
-    async def get_store_ids(self) -> Set[bytes32]:
+    async def get_store_ids(self) -> set[bytes32]:
         async with self.db_wrapper.reader() as reader:
             cursor = await reader.execute("SELECT DISTINCT tree_id FROM root")
 
@@ -597,7 +597,7 @@ class DataStore:
 
         return Root.from_row(row=row)
 
-    async def get_all_pending_batches_roots(self) -> List[Root]:
+    async def get_all_pending_batches_roots(self) -> list[Root]:
         async with self.db_wrapper.reader() as reader:
             cursor = await reader.execute(
                 """
@@ -623,7 +623,7 @@ class DataStore:
             return False
         return True
 
-    async def get_roots_between(self, store_id: bytes32, generation_begin: int, generation_end: int) -> List[Root]:
+    async def get_roots_between(self, store_id: bytes32, generation_begin: int, generation_end: int) -> list[Root]:
         async with self.db_wrapper.reader() as reader:
             cursor = await reader.execute(
                 "SELECT * FROM root WHERE tree_id == :tree_id "
@@ -658,7 +658,7 @@ class DataStore:
         node_hash: bytes32,
         store_id: bytes32,
         root_hash: Optional[bytes32] = None,
-    ) -> List[InternalNode]:
+    ) -> list[InternalNode]:
         async with self.db_wrapper.reader() as reader:
             if root_hash is None:
                 root = await self.get_tree_root(store_id=store_id)
@@ -702,7 +702,7 @@ class DataStore:
         store_id: bytes32,
         generation: Optional[int] = None,
         root_hash: Optional[bytes32] = None,
-    ) -> List[InternalNode]:
+    ) -> list[InternalNode]:
         async with self.db_wrapper.reader():
             nodes = []
             if root_hash is None:
@@ -725,7 +725,7 @@ class DataStore:
 
             return nodes
 
-    async def get_internal_nodes(self, store_id: bytes32, root_hash: Optional[bytes32] = None) -> List[InternalNode]:
+    async def get_internal_nodes(self, store_id: bytes32, root_hash: Optional[bytes32] = None) -> list[InternalNode]:
         async with self.db_wrapper.reader() as reader:
             if root_hash is None:
                 root = await self.get_tree_root(store_id=store_id)
@@ -745,7 +745,7 @@ class DataStore:
                 {"root_hash": root_hash, "node_type": NodeType.INTERNAL},
             )
 
-            internal_nodes: List[InternalNode] = []
+            internal_nodes: list[InternalNode] = []
             async for row in cursor:
                 node = row_to_node(row=row)
                 if not isinstance(node, InternalNode):
@@ -791,7 +791,7 @@ class DataStore:
         self,
         store_id: bytes32,
         root_hash: Union[bytes32, Unspecified] = unspecified,
-    ) -> List[TerminalNode]:
+    ) -> list[TerminalNode]:
         async with self.db_wrapper.reader() as reader:
             resolved_root_hash: Optional[bytes32]
             if root_hash is unspecified:
@@ -801,7 +801,7 @@ class DataStore:
                 resolved_root_hash = root_hash
 
             cursor = await self.get_keys_values_cursor(reader, resolved_root_hash)
-            terminal_nodes: List[TerminalNode] = []
+            terminal_nodes: list[TerminalNode] = []
             async for row in cursor:
                 if row["depth"] > 62:
                     # TODO: Review the value and implementation of left-to-right order
@@ -836,9 +836,9 @@ class DataStore:
                 resolved_root_hash = root_hash
 
             cursor = await self.get_keys_values_cursor(reader, resolved_root_hash)
-            keys_values_hashed: Dict[bytes32, bytes32] = {}
-            key_hash_to_length: Dict[bytes32, int] = {}
-            leaf_hash_to_length: Dict[bytes32, int] = {}
+            keys_values_hashed: dict[bytes32, bytes32] = {}
+            key_hash_to_length: dict[bytes32, int] = {}
+            leaf_hash_to_length: dict[bytes32, int] = {}
             async for row in cursor:
                 if row["depth"] > 62:
                     raise Exception("Tree depth exceeded 62, unable to guarantee left-to-right node order.")
@@ -853,8 +853,8 @@ class DataStore:
 
     async def get_leaf_hashes_by_hashed_key(
         self, store_id: bytes32, root_hash: Optional[bytes32] = None
-    ) -> Dict[bytes32, bytes32]:
-        result: Dict[bytes32, bytes32] = {}
+    ) -> dict[bytes32, bytes32]:
+        result: dict[bytes32, bytes32] = {}
         async with self.db_wrapper.reader() as reader:
             if root_hash is None:
                 root = await self.get_tree_root(store_id=store_id)
@@ -876,7 +876,7 @@ class DataStore:
         keys_values_compressed = await self.get_keys_values_compressed(store_id, root_hash)
         pagination_data = get_hashes_for_page(page, keys_values_compressed.key_hash_to_length, max_page_size)
 
-        keys: List[bytes] = []
+        keys: list[bytes] = []
         for hash in pagination_data.hashes:
             leaf_hash = keys_values_compressed.keys_values_hashed[hash]
             node = await self.get_node(leaf_hash)
@@ -900,7 +900,7 @@ class DataStore:
         keys_values_compressed = await self.get_keys_values_compressed(store_id, root_hash)
         pagination_data = get_hashes_for_page(page, keys_values_compressed.leaf_hash_to_length, max_page_size)
 
-        keys_values: List[TerminalNode] = []
+        keys_values: list[TerminalNode] = []
         for hash in pagination_data.hashes:
             node = await self.get_node(hash)
             assert isinstance(node, TerminalNode)
@@ -923,11 +923,11 @@ class DataStore:
         hash2: bytes32,
     ) -> KVDiffPaginationData:
         old_pairs = await self.get_keys_values_compressed(store_id, hash1)
-        if len(old_pairs.keys_values_hashed) == 0 and hash1 != bytes32([0] * 32):
+        if len(old_pairs.keys_values_hashed) == 0 and hash1 != bytes32.zeros:
             raise Exception(f"Unable to diff: Can't find keys and values for {hash1}")
 
         new_pairs = await self.get_keys_values_compressed(store_id, hash2)
-        if len(new_pairs.keys_values_hashed) == 0 and hash2 != bytes32([0] * 32):
+        if len(new_pairs.keys_values_hashed) == 0 and hash2 != bytes32.zeros:
             raise Exception(f"Unable to diff: Can't find keys and values for {hash2}")
 
         old_pairs_leaf_hashes = {v for v in old_pairs.keys_values_hashed.values()}
@@ -941,7 +941,7 @@ class DataStore:
             lengths[hash] = old_pairs.leaf_hash_to_length[hash]
 
         pagination_data = get_hashes_for_page(page, lengths, max_page_size)
-        kv_diff: List[DiffData] = []
+        kv_diff: list[DiffData] = []
 
         for hash in pagination_data.hashes:
             node = await self.get_node(hash)
@@ -1063,7 +1063,7 @@ class DataStore:
         self,
         store_id: bytes32,
         root_hash: Union[bytes32, Unspecified] = unspecified,
-    ) -> Dict[bytes, bytes]:
+    ) -> dict[bytes, bytes]:
         pairs = await self.get_keys_values(store_id=store_id, root_hash=root_hash)
         return {node.key: node.value for node in pairs}
 
@@ -1071,7 +1071,7 @@ class DataStore:
         self,
         store_id: bytes32,
         root_hash: Union[bytes32, Unspecified] = unspecified,
-    ) -> List[bytes]:
+    ) -> list[bytes]:
         async with self.db_wrapper.reader() as reader:
             if root_hash is unspecified:
                 root = await self.get_tree_root(store_id=store_id)
@@ -1094,7 +1094,7 @@ class DataStore:
                 {"root_hash": resolved_root_hash, "node_type": NodeType.TERMINAL},
             )
 
-            keys: List[bytes] = [row["key"] async for row in cursor]
+            keys: list[bytes] = [row["key"] async for row in cursor]
 
         return keys
 
@@ -1105,9 +1105,9 @@ class DataStore:
         root_hash: Optional[bytes32],
         generation: Optional[int] = None,
         use_optimized: bool = True,
-    ) -> List[InternalNode]:
+    ) -> list[InternalNode]:
         if use_optimized:
-            ancestors: List[InternalNode] = await self.get_ancestors_optimized(
+            ancestors: list[InternalNode] = await self.get_ancestors_optimized(
                 node_hash=node_hash,
                 store_id=store_id,
                 generation=generation,
@@ -1120,7 +1120,7 @@ class DataStore:
                 generation=generation,
                 root_hash=root_hash,
             )
-            ancestors_2: List[InternalNode] = await self.get_ancestors(
+            ancestors_2: list[InternalNode] = await self.get_ancestors(
                 node_hash=node_hash, store_id=store_id, root_hash=root_hash
             )
             if ancestors != ancestors_2:
@@ -1136,12 +1136,12 @@ class DataStore:
         left: bytes32,
         right: bytes32,
         traversal_node_hash: bytes32,
-        ancestors: List[InternalNode],
+        ancestors: list[InternalNode],
         status: Status,
         root: Root,
     ) -> Root:
         # update ancestors after inserting root, to keep table constraints.
-        insert_ancestors_cache: List[Tuple[bytes32, bytes32, bytes32]] = []
+        insert_ancestors_cache: list[tuple[bytes32, bytes32, bytes32]] = []
         new_generation = root.generation + 1
         # create first new internal node
         new_hash = await self._insert_internal_node(left_hash=left, right_hash=right)
@@ -1212,7 +1212,7 @@ class DataStore:
 
             if was_empty:
                 if side is not None:
-                    raise Exception("Tree was empty so side must be unspecified, got: {side!r}")
+                    raise Exception(f"Tree was empty so side must be unspecified, got: {side!r}")
 
                 new_root = await self._insert_root(
                     store_id=store_id,
@@ -1273,7 +1273,7 @@ class DataStore:
                 log.debug(f"Request to delete an unknown key ignored: {key.hex()}")
                 return root
 
-            ancestors: List[InternalNode] = await self.get_ancestors_common(
+            ancestors: list[InternalNode] = await self.get_ancestors_common(
                 node_hash=node_hash,
                 store_id=store_id,
                 root_hash=root_hash,
@@ -1306,7 +1306,7 @@ class DataStore:
             else:
                 new_generation = root.generation + 1
             # update ancestors after inserting root, to keep table constraints.
-            insert_ancestors_cache: List[Tuple[bytes32, bytes32, bytes32]] = []
+            insert_ancestors_cache: list[tuple[bytes32, bytes32, bytes32]] = []
             # more parents to handle so let's traverse them
             for ancestor in ancestors[1:]:
                 if ancestor.left_hash == old_child_hash:
@@ -1433,7 +1433,7 @@ class DataStore:
         else:
             await writer.execute(query, params)
 
-    async def get_nodes(self, node_hashes: List[bytes32]) -> List[Node]:
+    async def get_nodes(self, node_hashes: list[bytes32]) -> list[Node]:
         query_parameter_place_holders = ",".join("?" for _ in node_hashes)
         async with self.db_wrapper.reader() as reader:
             # TODO: handle SQLITE_MAX_VARIABLE_NUMBER
@@ -1452,9 +1452,9 @@ class DataStore:
         return [hash_to_node[node_hash] for node_hash in node_hashes]
 
     async def get_leaf_at_minimum_height(
-        self, root_hash: bytes32, hash_to_parent: Dict[bytes32, InternalNode]
+        self, root_hash: bytes32, hash_to_parent: dict[bytes32, InternalNode]
     ) -> TerminalNode:
-        queue: List[bytes32] = [root_hash]
+        queue: list[bytes32] = [root_hash]
         batch_size = min(500, SQLITE_MAX_VARIABLE_NUMBER - 10)
 
         while True:
@@ -1473,8 +1473,8 @@ class DataStore:
     async def batch_upsert(
         self,
         hash: bytes32,
-        to_update_hashes: Set[bytes32],
-        pending_upsert_new_hashes: Dict[bytes32, bytes32],
+        to_update_hashes: set[bytes32],
+        pending_upsert_new_hashes: dict[bytes32, bytes32],
     ) -> bytes32:
         if hash not in to_update_hashes:
             return hash
@@ -1488,7 +1488,7 @@ class DataStore:
     async def insert_batch(
         self,
         store_id: bytes32,
-        changelist: List[Dict[str, Any]],
+        changelist: list[dict[str, Any]],
         status: Status = Status.PENDING,
         enable_batch_autoinsert: bool = True,
     ) -> Optional[bytes32]:
@@ -1510,9 +1510,9 @@ class DataStore:
 
             assert latest_local_root is not None
 
-            key_hash_frequency: Dict[bytes32, int] = {}
-            first_action: Dict[bytes32, str] = {}
-            last_action: Dict[bytes32, str] = {}
+            key_hash_frequency: dict[bytes32, int] = {}
+            first_action: dict[bytes32, str] = {}
+            last_action: dict[bytes32, str] = {}
 
             for change in changelist:
                 key = change["key"]
@@ -1522,8 +1522,8 @@ class DataStore:
                     first_action[hash] = change["action"]
                 last_action[hash] = change["action"]
 
-            pending_autoinsert_hashes: List[bytes32] = []
-            pending_upsert_new_hashes: Dict[bytes32, bytes32] = {}
+            pending_autoinsert_hashes: list[bytes32] = []
+            pending_upsert_new_hashes: dict[bytes32, bytes32] = {}
             leaf_hashes = await self.get_leaf_hashes_by_hashed_key(store_id)
 
             for change in changelist:
@@ -1598,8 +1598,8 @@ class DataStore:
                     raise Exception(f"Operation in batch is not insert or delete: {change}")
 
             if len(pending_upsert_new_hashes) > 0:
-                to_update_hashes: Set[bytes32] = set(pending_upsert_new_hashes.keys())
-                to_update_queue: List[bytes32] = list(pending_upsert_new_hashes.keys())
+                to_update_hashes: set[bytes32] = set(pending_upsert_new_hashes.keys())
+                to_update_queue: list[bytes32] = list(pending_upsert_new_hashes.keys())
                 batch_size = min(500, SQLITE_MAX_VARIABLE_NUMBER - 10)
 
                 while len(to_update_queue) > 0:
@@ -1622,7 +1622,7 @@ class DataStore:
             # Start with the leaf nodes and pair them to form new nodes at the next level up, repeating this process
             # in a bottom-up fashion until a single root node remains. This constructs a balanced tree from the leaves.
             while len(pending_autoinsert_hashes) > 1:
-                new_hashes: List[bytes32] = []
+                new_hashes: list[bytes32] = []
                 for i in range(0, len(pending_autoinsert_hashes) - 1, 2):
                     internal_node_hash = await self._insert_internal_node(
                         pending_autoinsert_hashes[i], pending_autoinsert_hashes[i + 1]
@@ -1638,9 +1638,9 @@ class DataStore:
                 if latest_local_root is None or latest_local_root.node_hash is None:
                     await self._insert_root(store_id=store_id, node_hash=subtree_hash, status=Status.COMMITTED)
                 else:
-                    hash_to_parent: Dict[bytes32, InternalNode] = {}
+                    hash_to_parent: dict[bytes32, InternalNode] = {}
                     min_height_leaf = await self.get_leaf_at_minimum_height(latest_local_root.node_hash, hash_to_parent)
-                    ancestors: List[InternalNode] = []
+                    ancestors: list[InternalNode] = []
                     hash = min_height_leaf.hash
                     while hash in hash_to_parent:
                         node = hash_to_parent[hash]
@@ -1665,7 +1665,7 @@ class DataStore:
             # We delete all "temporary" records stored in root and ancestor tables and store only the final result.
             await self.rollback_to_generation(store_id, old_root.generation)
             await self.insert_root_with_ancestor_table(store_id=store_id, node_hash=root.node_hash, status=status)
-            if status in (Status.PENDING, Status.PENDING_BATCH):
+            if status in {Status.PENDING, Status.PENDING_BATCH}:
                 new_root = await self.get_pending_root(store_id=store_id)
                 assert new_root is not None
             elif status == Status.COMMITTED:
@@ -1712,10 +1712,10 @@ class DataStore:
 
     async def _get_one_ancestor_multiple_hashes(
         self,
-        node_hashes: List[bytes32],
+        node_hashes: list[bytes32],
         store_id: bytes32,
         generation: Optional[int] = None,
-    ) -> List[InternalNode]:
+    ) -> list[InternalNode]:
         async with self.db_wrapper.reader() as reader:
             node_hashes_place_holders = ",".join("?" for _ in node_hashes)
             if generation is None:
@@ -1747,14 +1747,14 @@ class DataStore:
             )
 
             if previous_root.node_hash is not None:
-                previous_internal_nodes: List[InternalNode] = await self.get_internal_nodes(
+                previous_internal_nodes: list[InternalNode] = await self.get_internal_nodes(
                     store_id=store_id,
                     root_hash=previous_root.node_hash,
                 )
-                known_hashes: Set[bytes32] = {node.hash for node in previous_internal_nodes}
+                known_hashes: set[bytes32] = {node.hash for node in previous_internal_nodes}
             else:
                 known_hashes = set()
-            internal_nodes: List[InternalNode] = await self.get_internal_nodes(
+            internal_nodes: list[InternalNode] = await self.get_internal_nodes(
                 store_id=store_id,
                 root_hash=root.node_hash,
             )
@@ -1809,7 +1809,7 @@ class DataStore:
             return node
 
     async def maybe_get_node_from_key_hash(
-        self, leaf_hashes: Dict[bytes32, bytes32], hash: bytes32
+        self, leaf_hashes: dict[bytes32, bytes32], hash: bytes32
     ) -> Optional[TerminalNode]:
         if hash in leaf_hashes:
             leaf_hash = leaf_hashes[hash]
@@ -1875,7 +1875,7 @@ class DataStore:
                 {"root_hash": root_node.hash},
             )
             nodes = [row_to_node(row=row) async for row in cursor]
-            hash_to_node: Dict[bytes32, Node] = {}
+            hash_to_node: dict[bytes32, Node] = {}
             for node in reversed(nodes):
                 if isinstance(node, InternalNode):
                     node = replace(node, left=hash_to_node[node.left_hash], right=hash_to_node[node.right_hash])
@@ -1904,7 +1904,7 @@ class DataStore:
         else:
             ancestors = await self.get_ancestors(node_hash=node_hash, store_id=store_id, root_hash=root_hash)
 
-        layers: List[ProofOfInclusionLayer] = []
+        layers: list[ProofOfInclusionLayer] = []
         child_hash = node_hash
         for parent in ancestors:
             layer = ProofOfInclusionLayer.from_internal_node(internal_node=parent, traversal_child_hash=child_hash)
@@ -1959,7 +1959,7 @@ class DataStore:
         deltas_only: bool,
         writer: BinaryIO,
     ) -> None:
-        if node_hash == bytes32([0] * 32):
+        if node_hash == bytes32.zeros:
             return
 
         if deltas_only:
@@ -1981,7 +1981,7 @@ class DataStore:
         writer.write(len(to_write).to_bytes(4, byteorder="big"))
         writer.write(to_write)
 
-    async def update_subscriptions_from_wallet(self, store_id: bytes32, new_urls: List[str]) -> None:
+    async def update_subscriptions_from_wallet(self, store_id: bytes32, new_urls: list[str]) -> None:
         async with self.db_wrapper.writer() as writer:
             cursor = await writer.execute(
                 "SELECT * FROM subscriptions WHERE from_wallet == 1 AND tree_id == :tree_id",
@@ -2053,7 +2053,7 @@ class DataStore:
                     },
                 )
 
-    async def remove_subscriptions(self, store_id: bytes32, urls: List[str]) -> None:
+    async def remove_subscriptions(self, store_id: bytes32, urls: list[str]) -> None:
         async with self.db_wrapper.writer() as writer:
             for url in urls:
                 await writer.execute(
@@ -2099,8 +2099,8 @@ class DataStore:
                     "pending_batch_status": Status.PENDING_BATCH.value,
                 },
             )
-            to_delete: Dict[bytes, Tuple[bytes, bytes]] = {}
-            ref_counts: Dict[bytes, int] = {}
+            to_delete: dict[bytes, tuple[bytes, bytes]] = {}
+            ref_counts: dict[bytes, int] = {}
             async for row in cursor:
                 hash = row["hash"]
                 left = row["left"]
@@ -2195,7 +2195,7 @@ class DataStore:
         await self.update_server_info(store_id, new_server_info)
         return new_server_info
 
-    async def get_available_servers_for_store(self, store_id: bytes32, timestamp: int) -> List[ServerInfo]:
+    async def get_available_servers_for_store(self, store_id: bytes32, timestamp: int) -> list[ServerInfo]:
         subscriptions = await self.get_subscriptions()
         subscription = next((subscription for subscription in subscriptions if subscription.store_id == store_id), None)
         if subscription is None:
@@ -2206,8 +2206,8 @@ class DataStore:
                 servers_info.append(server_info)
         return servers_info
 
-    async def get_subscriptions(self) -> List[Subscription]:
-        subscriptions: List[Subscription] = []
+    async def get_subscriptions(self) -> list[Subscription]:
+        subscriptions: list[Subscription] = []
 
         async with self.db_wrapper.reader() as reader:
             cursor = await reader.execute(
@@ -2244,14 +2244,14 @@ class DataStore:
         # NOTE: empty is expressed as zeros
         hash_1: bytes32,
         hash_2: bytes32,
-    ) -> Set[DiffData]:
+    ) -> set[DiffData]:
         async with self.db_wrapper.reader():
             old_pairs = set(await self.get_keys_values(store_id, hash_1))
-            if len(old_pairs) == 0 and hash_1 != bytes32([0] * 32):
+            if len(old_pairs) == 0 and hash_1 != bytes32.zeros:
                 raise Exception(f"Unable to diff: Can't find keys and values for {hash_1}")
 
             new_pairs = set(await self.get_keys_values(store_id, hash_2))
-            if len(new_pairs) == 0 and hash_2 != bytes32([0] * 32):
+            if len(new_pairs) == 0 and hash_2 != bytes32.zeros:
                 raise Exception(f"Unable to diff: Can't find keys and values for {hash_2}")
 
             insertions = {

chia/data_layer/dl_wallet_store.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import List, Optional, Type, TypeVar, Union
+from typing import Optional, TypeVar, Union
 
 from aiosqlite import Row
 
@@ -30,7 +30,7 @@ def _row_to_singleton_record(row: Row) -> SingletonRecord:
 
 
 def _row_to_mirror(row: Row, confirmed_at_height: Optional[uint32]) -> Mirror:
-    urls: List[bytes] = []
+    urls: list[bytes] = []
     byte_list: bytes = row[3]
     while byte_list != b"":
         length = uint16.from_bytes(byte_list[0:2])
@@ -48,7 +48,7 @@ class DataLayerStore:
     db_wrapper: DBWrapper2
 
     @classmethod
-    async def create(cls: Type[_T_DataLayerStore], db_wrapper: DBWrapper2) -> _T_DataLayerStore:
+    async def create(cls: type[_T_DataLayerStore], db_wrapper: DBWrapper2) -> _T_DataLayerStore:
         self = cls()
 
         self.db_wrapper = db_wrapper
@@ -131,11 +131,11 @@ class DataLayerStore:
         min_generation: Optional[uint32] = None,
         max_generation: Optional[uint32] = None,
         num_results: Optional[uint32] = None,
-    ) -> List[SingletonRecord]:
+    ) -> list[SingletonRecord]:
         """
         Returns stored singletons with a specific launcher ID.
         """
-        query_params: List[Union[bytes32, uint32]] = [launcher_id]
+        query_params: list[Union[bytes32, uint32]] = [launcher_id]
         for optional_param in (min_generation, max_generation, num_results):
             if optional_param is not None:
                 query_params.append(optional_param)
@@ -200,7 +200,7 @@ class DataLayerStore:
             return _row_to_singleton_record(row)
         return None
 
-    async def get_unconfirmed_singletons(self, launcher_id: bytes32) -> List[SingletonRecord]:
+    async def get_unconfirmed_singletons(self, launcher_id: bytes32) -> list[SingletonRecord]:
         """
         Returns all singletons with a specific launcher id that have not yet been marked confirmed
         """
@@ -214,7 +214,7 @@ class DataLayerStore:
 
         return records
 
-    async def get_singletons_by_root(self, launcher_id: bytes32, root: bytes32) -> List[SingletonRecord]:
+    async def get_singletons_by_root(self, launcher_id: bytes32, root: bytes32) -> list[SingletonRecord]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute(
                 "SELECT * from singleton_records WHERE launcher_id=? AND root=? ORDER BY generation DESC",
@@ -276,7 +276,7 @@ class DataLayerStore:
             return Coin(bytes32(row[1][0:32]), bytes32(row[1][32:64]), uint64(int.from_bytes(row[1][64:72], "big")))
         return None
 
-    async def get_all_launchers(self) -> List[bytes32]:
+    async def get_all_launchers(self) -> list[bytes32]:
         """
         Checks DB for all launchers.
         """
@@ -329,7 +329,7 @@ class DataLayerStore:
                 ),
             )
 
-    async def get_mirrors(self, launcher_id: bytes32) -> List[Mirror]:
+    async def get_mirrors(self, launcher_id: bytes32) -> list[Mirror]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute(
                 "SELECT * from mirrors WHERE launcher_id=?",
@@ -337,7 +337,7 @@ class DataLayerStore:
             )
             rows = await cursor.fetchall()
             await cursor.close()
-            mirrors: List[Mirror] = []
+            mirrors: list[Mirror] = []
 
             for row in rows:
                 confirmation_height = await execute_fetchone(

chia/data_layer/download_data.py

@@ -5,7 +5,7 @@ import logging
 import time
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Optional
+from typing import Optional
 
 import aiohttp
 from typing_extensions import Literal
@@ -145,7 +145,7 @@ async def write_files_for_root(
     if root.node_hash is not None:
         node_hash = root.node_hash
     else:
-        node_hash = bytes32([0] * 32)  # todo change
+        node_hash = bytes32.zeros  # todo change
 
     filename_full_tree = get_full_tree_filename_path(foldername, store_id, node_hash, root.generation, group_by_store)
     filename_diff_tree = get_delta_filename_path(foldername, store_id, node_hash, root.generation, group_by_store)
@@ -237,7 +237,7 @@ async def insert_from_delta_file(
     store_id: bytes32,
     existing_generation: int,
     target_generation: int,
-    root_hashes: List[bytes32],
+    root_hashes: list[bytes32],
     server_info: ServerInfo,
     client_foldername: Path,
     timeout: aiohttp.ClientTimeout,
@@ -291,7 +291,7 @@ async def insert_from_delta_file(
             num_inserted = await insert_into_data_store_from_file(
                 data_store,
                 store_id,
-                None if root_hash == bytes32([0] * 32) else root_hash,
+                None if root_hash == bytes32.zeros else root_hash,
                 target_filename_path,
             )
             log.info(
@@ -336,7 +336,7 @@ def delete_full_file_if_exists(foldername: Path, store_id: bytes32, root: Root)
     if root.node_hash is not None:
         node_hash = root.node_hash
     else:
-        node_hash = bytes32([0] * 32)  # todo change
+        node_hash = bytes32.zeros  # todo change
 
     not_found = 0
     for group_by_store in (True, False):