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

chia/_tests/core/util/test_streamable.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import io
 import re
 from dataclasses import dataclass, field, fields
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, get_type_hints
+from typing import Any, Callable, Optional, get_type_hints
 
 import pytest
 from chia_rs import G1Element
@@ -69,7 +69,7 @@ def test_dict_not_suppported() -> None:
         @streamable
         @dataclass(frozen=True)
         class TestClassDict(Streamable):
-            a: Dict[str, str]
+            a: dict[str, str]
 
 
 @dataclass(frozen=True)
@@ -118,8 +118,8 @@ class StreamableFromDict2(Streamable):
 @streamable
 @dataclass(frozen=True)
 class ConvertTupleFailures(Streamable):
-    a: Tuple[uint8, uint8]
-    b: Tuple[uint8, Tuple[uint8, uint8]]
+    a: tuple[uint8, uint8]
+    b: tuple[uint8, tuple[uint8, uint8]]
 
 
 @pytest.mark.parametrize(
@@ -137,7 +137,7 @@ class ConvertTupleFailures(Streamable):
         pytest.param({"a": (1, 1), "b": (1, "22")}, InvalidTypeError, id="b: invalid type str"),
     ],
 )
-def test_convert_tuple_failures(input_dict: Dict[str, Any], error: Any) -> None:
+def test_convert_tuple_failures(input_dict: dict[str, Any], error: Any) -> None:
     with pytest.raises(error):
         streamable_from_dict(ConvertTupleFailures, input_dict)
 
@@ -145,8 +145,8 @@ def test_convert_tuple_failures(input_dict: Dict[str, Any], error: Any) -> None:
 @streamable
 @dataclass(frozen=True)
 class ConvertListFailures(Streamable):
-    a: List[uint8]
-    b: List[List[uint8]]
+    a: list[uint8]
+    b: list[list[uint8]]
 
 
 @pytest.mark.parametrize(
@@ -160,7 +160,7 @@ class ConvertListFailures(Streamable):
         pytest.param({"a": [1, 1], "b": [1, "22"]}, InvalidTypeError, id="b: invalid type str"),
     ],
 )
-def test_convert_list_failures(input_dict: Dict[str, Any], error: Any) -> None:
+def test_convert_list_failures(input_dict: dict[str, Any], error: Any) -> None:
     with pytest.raises(error):
         streamable_from_dict(ConvertListFailures, input_dict)
 
@@ -189,7 +189,7 @@ class ConvertByteTypeFailures(Streamable):
         pytest.param({"a": "00000000", "b": "invalid"}, ConversionError, id="b: invalid hex string"),
     ],
 )
-def test_convert_byte_type_failures(input_dict: Dict[str, Any], error: Any) -> None:
+def test_convert_byte_type_failures(input_dict: dict[str, Any], error: Any) -> None:
     with pytest.raises(error):
         streamable_from_dict(ConvertByteTypeFailures, input_dict)
 
@@ -214,7 +214,7 @@ class ConvertUnhashableTypeFailures(Streamable):
         pytest.param({"a": b"\00" * G1Element.SIZE}, ValueError, "BLS Error G1InfinityInvalidBits"),
     ],
 )
-def test_convert_unhashable_type_failures(input_dict: Dict[str, Any], error: Any, error_msg: str) -> None:
+def test_convert_unhashable_type_failures(input_dict: dict[str, Any], error: Any, error_msg: str) -> None:
     with pytest.raises(error, match=re.escape(error_msg)):
         streamable_from_dict(ConvertUnhashableTypeFailures, input_dict)
 
@@ -240,7 +240,7 @@ class ConvertPrimitiveFailures(Streamable):
         pytest.param({"a": 0, "b": uint8(1), "c": NoStrClass()}, ConversionError, id="c: invalid value"),
     ],
 )
-def test_convert_primitive_failures(input_dict: Dict[str, Any], error: Any) -> None:
+def test_convert_primitive_failures(input_dict: dict[str, Any], error: Any) -> None:
     with pytest.raises(error):
         streamable_from_dict(ConvertPrimitiveFailures, input_dict)
 
@@ -309,7 +309,7 @@ def test_convert_primitive_failures(input_dict: Dict[str, Any], error: Any) -> N
     ],
 )
 def test_streamable_from_dict_failures(
-    test_class: Type[Streamable], input_dict: Dict[str, Any], error: Any, error_message: str
+    test_class: type[Streamable], input_dict: dict[str, Any], error: Any, error_message: str
 ) -> None:
     with pytest.raises(error, match=re.escape(error_message)):
         streamable_from_dict(test_class, input_dict)
@@ -320,7 +320,7 @@ def test_streamable_from_dict_failures(
 class TestFromJsonDictDefaultValues(Streamable):
     a: uint64 = uint64(1)
     b: str = "default"
-    c: List[uint64] = field(default_factory=list)
+    c: list[uint64] = field(default_factory=list)
 
 
 @pytest.mark.parametrize(
@@ -333,30 +333,30 @@ class TestFromJsonDictDefaultValues(Streamable):
         [{"a": 2, "b": "not_default", "c": [1, 2]}, {"a": 2, "b": "not_default", "c": [1, 2]}],
     ],
 )
-def test_from_json_dict_default_values(input_dict: Dict[str, object], output_dict: Dict[str, object]) -> None:
+def test_from_json_dict_default_values(input_dict: dict[str, object], output_dict: dict[str, object]) -> None:
     assert str(TestFromJsonDictDefaultValues.from_json_dict(input_dict).to_json_dict()) == str(output_dict)
 
 
 def test_basic_list() -> None:
     a = [1, 2, 3]
     assert is_type_List(type(a))
-    assert is_type_List(List)
-    assert is_type_List(List[int])
-    assert is_type_List(List[uint8])
     assert is_type_List(list)
-    assert not is_type_List(type(Tuple))
+    assert is_type_List(list[int])
+    assert is_type_List(list[uint8])
+    assert is_type_List(list)
+    assert not is_type_List(type(tuple))
     assert not is_type_List(tuple)
     assert not is_type_List(dict)
 
 
 def test_not_lists() -> None:
-    assert not is_type_List(Dict)
+    assert not is_type_List(dict)
 
 
 def test_basic_optional() -> None:
     assert is_type_SpecificOptional(Optional[int])
     assert is_type_SpecificOptional(Optional[Optional[int]])
-    assert not is_type_SpecificOptional(List[int])
+    assert not is_type_SpecificOptional(list[int])
 
 
 @streamable
@@ -388,15 +388,15 @@ class PostInitTestClassOptional(Streamable):
 @streamable
 @dataclass(frozen=True)
 class PostInitTestClassList(Streamable):
-    a: List[uint8]
-    b: List[List[G1Element]]
+    a: list[uint8]
+    b: list[list[G1Element]]
 
 
 @streamable
 @dataclass(frozen=True)
 class PostInitTestClassTuple(Streamable):
-    a: Tuple[uint8, str]
-    b: Tuple[Tuple[uint8, str], bytes32]
+    a: tuple[uint8, str]
+    b: tuple[tuple[uint8, str], bytes32]
 
 
 @pytest.mark.parametrize(
@@ -410,8 +410,8 @@ class PostInitTestClassTuple(Streamable):
         (PostInitTestClassOptional, (12, None, 13, None)),
     ],
 )
-def test_post_init_valid(test_class: Type[Any], args: Tuple[Any, ...]) -> None:
-    def validate_item_type(type_in: Type[Any], item: object) -> bool:
+def test_post_init_valid(test_class: type[Any], args: tuple[Any, ...]) -> None:
+    def validate_item_type(type_in: type[Any], item: object) -> bool:
         if is_type_SpecificOptional(type_in):
             return item is None or validate_item_type(get_args(type_in)[0], item)
         if is_type_Tuple(type_in):
@@ -449,7 +449,7 @@ def test_post_init_valid(test_class: Type[Any], args: Tuple[Any, ...]) -> None:
         (PostInitTestClassOptional, ([], None, None, None), ValueError),
     ],
 )
-def test_post_init_failures(test_class: Type[Any], args: Tuple[Any, ...], expected_exception: Type[Exception]) -> None:
+def test_post_init_failures(test_class: type[Any], args: tuple[Any, ...], expected_exception: type[Exception]) -> None:
     with pytest.raises(expected_exception):
         test_class(*args)
 
@@ -460,14 +460,14 @@ def test_basic() -> None:
     class TestClass(Streamable):
         a: uint32
         b: uint32
-        c: List[uint32]
-        d: List[List[uint32]]
+        c: list[uint32]
+        d: list[list[uint32]]
         e: Optional[uint32]
         f: Optional[uint32]
-        g: Tuple[uint32, str, bytes]
+        g: tuple[uint32, str, bytes]
 
     # we want to test invalid here, hence the ignore.
-    a = TestClass(24, 352, [1, 2, 4], [[1, 2, 3], [3, 4]], 728, None, (383, "hello", b"goodbye"))  # type: ignore[arg-type,list-item] # noqa: E501
+    a = TestClass(24, 352, [1, 2, 4], [[1, 2, 3], [3, 4]], 728, None, (383, "hello", b"goodbye"))  # type: ignore[arg-type,list-item]
 
     b: bytes = bytes(a)
     assert a == TestClass.from_bytes(b)
@@ -493,7 +493,7 @@ def test_variable_size() -> None:
 
 
 def test_json(bt: BlockTools) -> None:
-    block = bt.create_genesis_block(test_constants, bytes32([0] * 32), uint64(0))
+    block = bt.create_genesis_block(test_constants, bytes32.zeros, uint64(0))
     dict_block = block.to_json_dict()
     assert FullBlock.from_json_dict(dict_block) == block
 
@@ -503,7 +503,7 @@ def test_json(bt: BlockTools) -> None:
 class OptionalTestClass(Streamable):
     a: Optional[str]
     b: Optional[bool]
-    c: Optional[List[Optional[str]]]
+    c: Optional[list[Optional[str]]]
 
 
 @pytest.mark.parametrize(
@@ -517,7 +517,7 @@ class OptionalTestClass(Streamable):
         (None, None, None),
     ],
 )
-def test_optional_json(a: Optional[str], b: Optional[bool], c: Optional[List[Optional[str]]]) -> None:
+def test_optional_json(a: Optional[str], b: Optional[bool], c: Optional[list[Optional[str]]]) -> None:
     obj: OptionalTestClass = OptionalTestClass.from_json_dict({"a": a, "b": b, "c": c})
     assert obj.a == a
     assert obj.b == b
@@ -527,14 +527,14 @@ def test_optional_json(a: Optional[str], b: Optional[bool], c: Optional[List[Opt
 @streamable
 @dataclass(frozen=True)
 class TestClassRecursive1(Streamable):
-    a: List[uint32]
+    a: list[uint32]
 
 
 @streamable
 @dataclass(frozen=True)
 class TestClassRecursive2(Streamable):
     a: uint32
-    b: List[Optional[List[TestClassRecursive1]]]
+    b: list[Optional[list[TestClassRecursive1]]]
     c: bytes32
 
 
@@ -586,7 +586,7 @@ def test_ambiguous_deserialization_list() -> None:
     @streamable
     @dataclass(frozen=True)
     class TestClassList(Streamable):
-        a: List[uint8]
+        a: list[uint8]
 
     # Does not have the required elements
     with pytest.raises(ValueError):
@@ -597,7 +597,7 @@ def test_ambiguous_deserialization_tuple() -> None:
     @streamable
     @dataclass(frozen=True)
     class TestClassTuple(Streamable):
-        a: Tuple[uint8, str]
+        a: tuple[uint8, str]
 
     # Does not have the required elements
     with pytest.raises(AssertionError):

chia/_tests/db/test_db_wrapper.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, List, Optional, Type
+from typing import TYPE_CHECKING, Callable, Optional
 
 import aiosqlite
 import pytest
@@ -14,6 +14,7 @@ from _pytest.fixtures import SubRequest
 from chia._tests.util.db_connection import DBConnection, PathDBConnection
 from chia._tests.util.misc import Marks, boolean_datacases, datacases
 from chia.util.db_wrapper import DBWrapper2, ForeignKeyError, InternalError, NestedForeignKeyDelayedRequestError
+from chia.util.task_referencer import create_referenced_task
 
 if TYPE_CHECKING:
     ConnectionContextManager = contextlib.AbstractAsyncContextManager[aiosqlite.core.Connection]
@@ -54,7 +55,7 @@ async def decrement_counter(db_wrapper: DBWrapper2) -> None:
         await connection.execute("UPDATE counter SET value = :value", {"value": new_value})
 
 
-async def sum_counter(db_wrapper: DBWrapper2, output: List[int]) -> None:
+async def sum_counter(db_wrapper: DBWrapper2, output: list[int]) -> None:
     async with db_wrapper.reader_no_transaction() as connection:
         async with connection.execute("SELECT value FROM counter") as cursor:
             row = await cursor.fetchone()
@@ -119,7 +120,7 @@ async def test_concurrent_writers(acquire_outside: bool, get_reader_method: GetR
 
             tasks = []
             for index in range(concurrent_task_count):
-                task = asyncio.create_task(increment_counter(db_wrapper))
+                task = create_referenced_task(increment_counter(db_wrapper))
                 tasks.append(task)
 
         await asyncio.wait_for(asyncio.gather(*tasks), timeout=None)
@@ -263,7 +264,7 @@ async def test_only_transactioned_reader_ignores_writer(transactioned: bool) ->
         async with get_reader() as reader:
             assert await query_value(connection=reader) == 0
 
-            task = asyncio.create_task(write())
+            task = create_referenced_task(write())
             await writer_committed.wait()
 
             assert await query_value(connection=reader) == 0 if transactioned else 1
@@ -340,9 +341,9 @@ async def test_concurrent_readers(acquire_outside: bool, get_reader_method: GetR
                 await exit_stack.enter_async_context(get_reader_method(db_wrapper)())
 
             tasks = []
-            values: List[int] = []
+            values: list[int] = []
             for index in range(concurrent_task_count):
-                task = asyncio.create_task(sum_counter(db_wrapper, values))
+                task = create_referenced_task(sum_counter(db_wrapper, values))
                 tasks.append(task)
 
         await asyncio.wait_for(asyncio.gather(*tasks), timeout=None)
@@ -369,13 +370,13 @@ async def test_mixed_readers_writers(acquire_outside: bool, get_reader_method: G
                 await exit_stack.enter_async_context(get_reader_method(db_wrapper)())
 
             tasks = []
-            values: List[int] = []
+            values: list[int] = []
             for index in range(concurrent_task_count):
-                task = asyncio.create_task(increment_counter(db_wrapper))
+                task = create_referenced_task(increment_counter(db_wrapper))
                 tasks.append(task)
-                task = asyncio.create_task(decrement_counter(db_wrapper))
+                task = create_referenced_task(decrement_counter(db_wrapper))
                 tasks.append(task)
-                task = asyncio.create_task(sum_counter(db_wrapper, values))
+                task = create_referenced_task(sum_counter(db_wrapper, values))
                 tasks.append(task)
 
         await asyncio.wait_for(asyncio.gather(*tasks), timeout=None)
@@ -495,11 +496,11 @@ async def test_foreign_key_pragma_rolls_back_on_foreign_key_error() -> None:
 @dataclass
 class RowFactoryCase:
     id: str
-    factory: Optional[Type[aiosqlite.Row]]
+    factory: Optional[type[aiosqlite.Row]]
     marks: Marks = ()
 
 
-row_factory_cases: List[RowFactoryCase] = [
+row_factory_cases: list[RowFactoryCase] = [
     RowFactoryCase(id="default named tuple", factory=None),
     RowFactoryCase(id="aiosqlite row", factory=aiosqlite.Row),
 ]

chia/_tests/environments/common.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import ClassVar, Protocol, Tuple, TypeVar
+from typing import ClassVar, Protocol, TypeVar
 
 from chia.rpc.rpc_server import RpcApiProtocol, RpcServer, RpcServiceProtocol
 from chia.server.api_protocol import ApiProtocol
@@ -17,7 +17,7 @@ T_PeerApi = TypeVar("T_PeerApi", bound=ApiProtocol)
 class ServiceEnvironment(Protocol[T_Node, T_RpcApi, T_PeerApi]):
     service: Service[T_Node, T_PeerApi, T_RpcApi]
 
-    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    __match_args__: ClassVar[tuple[str, ...]] = ()
 
     @property
     def node(self) -> T_Node: ...

chia/_tests/environments/full_node.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, ClassVar, Tuple, cast
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from chia._tests.environments.common import ServiceEnvironment
 from chia.full_node.full_node import FullNode
@@ -20,7 +20,7 @@ class FullNodeEnvironment:
             None,
         )
 
-    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    __match_args__: ClassVar[tuple[str, ...]] = ()
 
     service: Service[FullNode, FullNodeSimulator, SimulatorFullNodeRpcApi]