chia-blockchain 2.4.3b2__tar.gz → 2.4.3rc1__tar.gz

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chia-blockchain
-Version: 2.4.3b2
+Version: 2.4.3rc1
 Summary: Chia blockchain full node, farmer, timelord, and wallet.
 Home-page: https://chia.net/
 License: Apache License
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: dev
 Provides-Extra: legacy-keyring
 Provides-Extra: upnp
-Requires-Dist: aiofiles (==23.2.1)
+Requires-Dist: aiofiles (==24.1.0)
 Requires-Dist: aiohttp (==3.9.5)
 Requires-Dist: aiohttp_cors (==0.7.0) ; extra == "dev"
 Requires-Dist: aiosqlite (==0.20.0)
@@ -47,7 +47,7 @@ Requires-Dist: flake8 (==7.0.0) ; extra == "dev"
 Requires-Dist: hsms (==0.3.1)
 Requires-Dist: importlib-resources (==6.4.0)
 Requires-Dist: isort (==5.13.2) ; extra == "dev"
-Requires-Dist: keyring (==25.1.0)
+Requires-Dist: keyring (==25.2.1)
 Requires-Dist: keyrings.cryptfile (==1.3.9) ; extra == "legacy-keyring"
 Requires-Dist: lxml (==5.2.2) ; extra == "dev"
 Requires-Dist: miniupnpc (==2.2.2) ; extra == "upnp"

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/_tests/core/data_layer/test_data_store.py

@@ -1357,7 +1357,7 @@ async def test_server_http_ban(
         filename: str,
         proxy_url: str,
         server_info: ServerInfo,
-        timeout: int,
+        timeout: aiohttp.ClientTimeout,
         log: logging.Logger,
     ) -> None:
         if error:
@@ -1373,7 +1373,7 @@ async def test_server_http_ban(
             root_hashes=[bytes32.random(seeded_random)],
             server_info=sinfo,
             client_foldername=tmp_path,
-            timeout=15,
+            timeout=aiohttp.ClientTimeout(total=15, sock_connect=5),
             log=log,
             proxy_url="",
             downloader=None,
@@ -1396,7 +1396,7 @@ async def test_server_http_ban(
             root_hashes=[bytes32.random(seeded_random)],
             server_info=sinfo,
             client_foldername=tmp_path,
-            timeout=15,
+            timeout=aiohttp.ClientTimeout(total=15, sock_connect=5),
             log=log,
             proxy_url="",
             downloader=None,
@@ -1903,7 +1903,7 @@ async def test_insert_from_delta_file_correct_file_exists(
         root_hashes=root_hashes,
         server_info=sinfo,
         client_foldername=tmp_path,
-        timeout=15,
+        timeout=aiohttp.ClientTimeout(total=15, sock_connect=5),
         log=log,
         proxy_url="",
         downloader=None,
@@ -1962,7 +1962,7 @@ async def test_insert_from_delta_file_incorrect_file_exists(
         root_hashes=[incorrect_root_hash],
         server_info=sinfo,
         client_foldername=tmp_path,
-        timeout=15,
+        timeout=aiohttp.ClientTimeout(total=15, sock_connect=5),
         log=log,
         proxy_url="",
         downloader=None,

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/_tests/core/test_full_node_rpc.py

@@ -7,6 +7,7 @@ import pytest
 from chia_rs import AugSchemeMPL
 from clvm.casts import int_to_bytes
 
+from chia import __version__
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia._tests.conftest import ConsensusMode
 from chia._tests.connection_utils import connect_and_get_peer
@@ -577,6 +578,23 @@ async def test_get_network_info(one_wallet_and_one_simulator_services, self_host
         }
 
 
+@pytest.mark.anyio
+async def test_get_version(one_wallet_and_one_simulator_services, self_hostname):
+    nodes, _, bt = one_wallet_and_one_simulator_services
+    (full_node_service_1,) = nodes
+    async with FullNodeRpcClient.create_as_context(
+        self_hostname,
+        full_node_service_1.rpc_server.listen_port,
+        full_node_service_1.root_path,
+        full_node_service_1.config,
+    ) as client:
+        version = await client.fetch("get_version", {})
+        assert version == {
+            "success": True,
+            "version": __version__,
+        }
+
+
 @pytest.mark.anyio
 async def test_get_blockchain_state(one_wallet_and_one_simulator_services, self_hostname):
     num_blocks = 5

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/_tests/farmer_harvester/test_farmer.py

@@ -6,12 +6,14 @@ from dataclasses import dataclass
 from time import time
 from types import TracebackType
 from typing import Any, Dict, List, Optional, Tuple, Type, Union, cast
+from unittest.mock import ANY
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
 from pytest_mock import MockerFixture
 from yarl import URL
 
+from chia import __version__
 from chia._tests.conftest import HarvesterFarmerEnvironment
 from chia._tests.util.misc import DataCase, Marks, datacases
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
@@ -85,9 +87,11 @@ class IncrementPoolStatsCase:
 class DummyHarvesterPeer:
     return_invalid_response: bool
     peer_node_id: bytes32 = std_hash(b"1")
+    version: str
 
-    def __init__(self, return_valid_response: bool):
-        self.return_invalid_response = return_valid_response
+    def __init__(self, return_invalid_response: bool = False, version: str = "1.0.0"):
+        self.return_invalid_response = return_invalid_response
+        self.version = version
 
     async def send_message(self, arg1: Any) -> None:
         pass
@@ -1201,3 +1205,59 @@ async def test_farmer_pool_info_config_update(
     assert len(config["pool"]["pool_list"]) == 1
     assert config["pool"]["pool_list"][0]["p2_singleton_puzzle_hash"] == p2_singleton_puzzle_hash.hex()
     assert config["pool"]["pool_list"][0]["pool_url"] == case.expected_pool_url_in_config
+
+
+@dataclass
+class PartialSubmitHeaderCase(DataCase):
+    _id: str
+    harvester_peer: DummyHarvesterPeer
+    expected_headers: Dict[str, str]
+    marks: Marks = ()
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+
+@datacases(
+    PartialSubmitHeaderCase(
+        "additional version headers",
+        harvester_peer=DummyHarvesterPeer(
+            version="1.2.3.asdf42",
+        ),
+        expected_headers={
+            "User-Agent": f"Chia Blockchain v.{__version__}",
+            "chia-farmer-version": __version__,
+            "chia-harvester-version": "1.2.3.asdf42",
+        },
+    ),
+)
+@pytest.mark.anyio
+async def test_farmer_additional_headers_on_partial_submit(
+    mocker: MockerFixture,
+    farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    case: PartialSubmitHeaderCase,
+) -> None:
+    _, farmer_service, _ = farmer_one_harvester
+    assert farmer_service.rpc_server is not None
+    farmer_api = farmer_service._api
+
+    sp, pos, new_pos = create_valid_pos(farmer_api.farmer)
+    assert pos.pool_contract_puzzle_hash is not None
+
+    assert (
+        verify_and_get_quality_string(
+            pos, DEFAULT_CONSTANTS, sp.challenge_hash, sp.challenge_chain_sp, height=uint32(1)
+        )
+        is not None
+    )
+
+    mock_http_post = mocker.patch(
+        "aiohttp.ClientSession.post",
+        return_value=DummyPoolResponse(True, 200, new_difficulty=123),
+    )
+
+    peer = cast(WSChiaConnection, case.harvester_peer)
+    await farmer_api.new_proof_of_space(new_pos, peer)
+
+    mock_http_post.assert_called_once_with(ANY, json=ANY, ssl=ANY, headers=case.expected_headers)

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/_tests/pools/test_pool_rpc.py

@@ -438,10 +438,11 @@ class TestPoolWalletRpc:
             assert bal["confirmed_wallet_balance"] == 2 * 1_750_000_000_000
 
             # Claim 2 * 1.75, and farm a new 1.75
-            absorb_tx: TransactionRecord = (await client.pw_absorb_rewards(2, uint64(fee)))["transaction"]
-            await full_node_api.wait_transaction_records_entered_mempool(records=[absorb_tx])
+            absorb_txs: List[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee)))["transactions"]
+            await full_node_api.wait_transaction_records_entered_mempool(records=absorb_txs)
             await full_node_api.farm_blocks_to_puzzlehash(count=2, farm_to=our_ph, guarantee_transaction_blocks=True)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
+            await full_node_api.check_transactions_confirmed(wallet_node.wallet_state_manager, absorb_txs)
             new_status: PoolWalletInfo = (await client.pw_status(2))[0]
             assert status.current == new_status.current
             assert status.tip_singleton_coin_id != new_status.tip_singleton_coin_id
@@ -449,9 +450,9 @@ class TestPoolWalletRpc:
             assert bal["confirmed_wallet_balance"] == 1 * 1_750_000_000_000
 
             # Claim another 1.75
-            absorb_tx1: TransactionRecord = (await client.pw_absorb_rewards(2, uint64(fee)))["transaction"]
+            absorb_txs1: List[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee)))["transactions"]
 
-            await full_node_api.wait_transaction_records_entered_mempool(records=[absorb_tx1])
+            await full_node_api.wait_transaction_records_entered_mempool(records=absorb_txs1)
 
             await full_node_api.farm_blocks_to_puzzlehash(count=2, farm_to=our_ph, guarantee_transaction_blocks=True)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/_tests/util/rpc.py

@@ -16,6 +16,7 @@ async def validate_get_routes(client: RpcClient, api: RpcApiProtocol) -> None:
         "/close_connection",
         "/stop_node",
         "/get_routes",
+        "/get_version",
         "/healthz",
     ]
     assert len(routes_api) > 0

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/_tests/wallet/test_wallet_node.py

@@ -720,3 +720,34 @@ async def test_wallet_node_bad_coin_state_ignore(
 
     with pytest.raises(PeerRequestException):
         await wallet_node.get_coin_state([], wallet_node.get_full_node_peer())
+
+
+@pytest.mark.anyio
+@pytest.mark.standard_block_tools
+async def test_start_with_multiple_key_types(
+    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: List[FullBlock]
+) -> None:
+    [full_node_api], [(wallet_node, wallet_server)], bt = simulator_and_wallet
+
+    async def restart_with_fingerprint(fingerprint: Optional[int]) -> None:
+        wallet_node._close()
+        await wallet_node._await_closed(shutting_down=False)
+        await wallet_node._start_with_fingerprint(fingerprint=fingerprint)
+
+    initial_sk = wallet_node.wallet_state_manager.private_key
+
+    pk: G1Element = await wallet_node.keychain_proxy.add_key(
+        "c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        None,
+        private=False,
+    )
+    fingerprint_pk: int = pk.get_fingerprint()
+
+    await restart_with_fingerprint(fingerprint_pk)
+    assert wallet_node.wallet_state_manager.private_key is None
+    assert wallet_node.wallet_state_manager.root_pubkey == G1Element()
+
+    await wallet_node.keychain_proxy.delete_key_by_fingerprint(fingerprint_pk)
+
+    await restart_with_fingerprint(fingerprint_pk)
+    assert wallet_node.wallet_state_manager.private_key == initial_sk

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/daemon/keychain_proxy.py

@@ -365,7 +365,12 @@ class KeychainProxy(DaemonProxy):
                             break
                     else:
                         raise KeychainKeyNotFound(fingerprint)
-                key = selected_key.private_key if private else selected_key.public_key
+                if private and selected_key.secrets is not None:
+                    key = selected_key.private_key
+                elif not private:
+                    key = selected_key.public_key
+                else:
+                    return None
         else:
             response, success = await self.get_response_for_request(
                 "get_key_for_fingerprint", {"fingerprint": fingerprint, "private": private}

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/data_layer/data_layer.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import dataclasses
+import functools
 import json
 import logging
 import os
@@ -124,6 +125,9 @@ class DataLayer:
     _wallet_rpc: Optional[WalletRpcClient] = None
     subscription_lock: asyncio.Lock = dataclasses.field(default_factory=asyncio.Lock)
     subscription_update_concurrency: int = 5
+    client_timeout: aiohttp.ClientTimeout = dataclasses.field(
+        default_factory=functools.partial(aiohttp.ClientTimeout, total=45, sock_connect=5)
+    )
 
     @property
     def server(self) -> ChiaServer:
@@ -185,6 +189,9 @@ class DataLayer:
             maximum_full_file_count=config.get("maximum_full_file_count", 1),
             subscription_update_concurrency=config.get("subscription_update_concurrency", 5),
             unsubscribe_data_queue=[],
+            client_timeout=aiohttp.ClientTimeout(
+                total=config.get("client_timeout", 45), sock_connect=config.get("connect_timeout", 5)
+            ),
         )
 
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
@@ -586,7 +593,6 @@ class DataLayer:
                 max_generation=singleton_record.generation,
             )
             try:
-                timeout = self.config.get("client_timeout", 15)
                 proxy_url = self.config.get("proxy_url", None)
                 success = await insert_from_delta_file(
                     self.data_store,
@@ -595,7 +601,7 @@ class DataLayer:
                     [record.root for record in reversed(to_download)],
                     server_info,
                     self.server_files_location,
-                    timeout,
+                    self.client_timeout,
                     self.log,
                     proxy_url,
                     await self.get_downloader(store_id, url),

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/data_layer/download_data.py

@@ -145,7 +145,7 @@ async def insert_from_delta_file(
     root_hashes: List[bytes32],
     server_info: ServerInfo,
     client_foldername: Path,
-    timeout: int,
+    timeout: aiohttp.ClientTimeout,
     log: logging.Logger,
     proxy_url: str,
     downloader: Optional[PluginRemote],
@@ -164,7 +164,14 @@ async def insert_from_delta_file(
             if downloader is None:
                 # use http downloader - this raises on any error
                 try:
-                    await http_download(client_foldername, filename, proxy_url, server_info, timeout, log)
+                    await http_download(
+                        client_foldername,
+                        filename,
+                        proxy_url,
+                        server_info,
+                        timeout,
+                        log,
+                    )
                 except (asyncio.TimeoutError, aiohttp.ClientError):
                     new_server_info = await data_store.server_misses_file(store_id, server_info, timestamp)
                     log.info(
@@ -252,7 +259,7 @@ async def http_download(
     filename: str,
     proxy_url: str,
     server_info: ServerInfo,
-    timeout: int,
+    timeout: aiohttp.ClientTimeout,
     log: logging.Logger,
 ) -> None:
     """
@@ -262,7 +269,10 @@ async def http_download(
     async with aiohttp.ClientSession() as session:
         headers = {"accept-encoding": "gzip"}
         async with session.get(
-            server_info.url + "/" + filename, headers=headers, timeout=timeout, proxy=proxy_url
+            server_info.url + "/" + filename,
+            headers=headers,
+            timeout=timeout,
+            proxy=proxy_url,
         ) as resp:
             resp.raise_for_status()
             size = int(resp.headers.get("content-length", 0))

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/farmer/farmer_api.py

@@ -361,7 +361,11 @@ class FarmerAPI:
                             f"{pool_url}/partial",
                             json=post_partial_request.to_json_dict(),
                             ssl=ssl_context_for_root(get_mozilla_ca_crt(), log=self.farmer.log),
-                            headers={"User-Agent": f"Chia Blockchain v.{__version__}"},
+                            headers={
+                                "User-Agent": f"Chia Blockchain v.{__version__}",
+                                "chia-farmer-version": __version__,
+                                "chia-harvester-version": peer.version,
+                            },
                         ) as resp:
                             if not resp.ok:
                                 self.farmer.log.error(f"Error sending partial to {pool_url}, {resp.status}")

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/pools/pool_config.py

@@ -92,7 +92,7 @@ def update_pool_config_entry(
         updated = False
         for pool_config_dict in pool_list:
             try:
-                if hexstr_to_bytes(pool_config_dict["owner_public_key"]) == bytes(pool_wallet_config.owner_public_key):
+                if hexstr_to_bytes(pool_config_dict["launcher_id"]) == bytes(pool_wallet_config.launcher_id):
                     if update_closure(pool_config_dict):
                         updated = True
             except Exception as e:
@@ -101,6 +101,8 @@ def update_pool_config_entry(
         log.info(update_log_message)
         config["pool"]["pool_list"] = pool_list
         save_config(root_path, "config.yaml", config)
+    else:
+        log.error(f"Failed to update pool config entry for launcher_id {pool_wallet_config.launcher_id}")
 
 
 async def update_pool_config(root_path: Path, pool_config_list: List[PoolWalletConfig]) -> None:

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/rpc/rpc_server.py

@@ -13,6 +13,7 @@ from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Generic, List,
 from aiohttp import ClientConnectorError, ClientSession, ClientWebSocketResponse, WSMsgType, web
 from typing_extensions import Protocol, final
 
+from chia import __version__
 from chia.rpc.util import wrap_http_handler
 from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer, ssl_context_for_client, ssl_context_for_server
@@ -241,6 +242,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             "/close_connection": self.close_connection,
             "/stop_node": self.stop_node,
             "/get_routes": self.get_routes,
+            "/get_version": self.get_version,
             "/healthz": self.healthz,
         }
 
@@ -301,6 +303,11 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             "success": True,
         }
 
+    async def get_version(self, request: Dict[str, Any]) -> EndpointResult:
+        return {
+            "version": __version__,
+        }
+
     async def ws_api(self, message: WsRpcMessage) -> Optional[Dict[str, object]]:
         """
         This function gets called when new message is received via websocket.

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/util/initial-config.yaml

@@ -615,7 +615,8 @@ data_layer:
   # The location where the server files will be stored.
   server_files_location: "data_layer/db/server_files_location_CHALLENGE"
   # The timeout for the client to download a file from a server
-  client_timeout: 15
+  client_timeout: 45
+  connect_timeout: 5
   # If you need use a proxy for download data you can use this setting sample
   # proxy_url: http://localhost:8888
 

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/chia/wallet/wallet_node.py

@@ -271,7 +271,9 @@ class WalletNode:
 
         return key
 
-    async def get_key(self, fingerprint: Optional[int], private: bool = True) -> Optional[Union[PrivateKey, G1Element]]:
+    async def get_key(
+        self, fingerprint: Optional[int], private: bool = True, find_a_default: bool = True
+    ) -> Optional[Union[PrivateKey, G1Element]]:
         """
         Attempt to get the private key for the given fingerprint. If the fingerprint is None,
         get_key_for_fingerprint() will return the first private key. Similarly, if a key isn't
@@ -279,7 +281,7 @@ class WalletNode:
         """
         key: Optional[Union[PrivateKey, G1Element]] = await self.get_key_for_fingerprint(fingerprint, private=private)
 
-        if key is None and fingerprint is not None:
+        if key is None and fingerprint is not None and find_a_default:
             key = await self.get_key_for_fingerprint(None, private=private)
             if key is not None:
                 if isinstance(key, PrivateKey):
@@ -413,15 +415,19 @@ class WalletNode:
         multiprocessing_context = multiprocessing.get_context(method=multiprocessing_start_method)
         self._weight_proof_handler = WalletWeightProofHandler(self.constants, multiprocessing_context)
         self.synced_peers = set()
-        private_key = await self.get_key(fingerprint, private=True)
+        public_key = None
+        private_key = await self.get_key(fingerprint, private=True, find_a_default=False)
         if private_key is None:
-            public_key = await self.get_key(fingerprint, private=False)
-        else:
-            assert isinstance(private_key, PrivateKey)
-            public_key = private_key.get_g1()
+            public_key = await self.get_key(fingerprint, private=False, find_a_default=False)
+
         if public_key is None:
-            self.log_out()
-            return False
+            private_key = await self.get_key(None, private=True, find_a_default=True)
+            if private_key is not None:
+                assert isinstance(private_key, PrivateKey)
+                public_key = private_key.get_g1()
+            else:
+                self.log_out()
+                return False
         assert isinstance(public_key, G1Element)
         # override with private key fetched in case it's different from what was passed
         if fingerprint is None:

{chia_blockchain-2.4.3b2 → chia_blockchain-2.4.3rc1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "chia-blockchain"
 # see [tool.poetry-dynamic-versioning]
-version = "2.4.3-b2"
+version = "2.4.3-rc1"
 description = "Chia blockchain full node, farmer, timelord, and wallet."
 authors = ["Mariano Sorgente <mariano@chia.net>"]
 license = "Apache License"
@@ -38,7 +38,7 @@ priority = "supplemental"
 
 [tool.poetry.dependencies]
 python = ">=3.8.10, <3.13"
-aiofiles = "23.2.1"  # Async IO for files
+aiofiles = "24.1.0"  # Async IO for files
 aiohttp = "3.9.5"  # HTTP server for full node rpc
 aiosqlite = "0.20.0"  # asyncio wrapper for sqlite, to store blocks
 anyio = "4.3.0"
@@ -59,7 +59,7 @@ cryptography = "42.0.8"  # Python cryptography library for TLS - keyring conflic
 dnslib = "0.9.24"  # dns lib
 dnspython = "2.6.1"  # Query DNS seeds
 filelock = "3.15.4"  # For reading and writing config multiprocess and multithread safely  (non-reentrant locks)
-keyring = "25.1.0"  # Store keys in MacOS Keychain, Windows Credential Locker
+keyring = "25.2.1"  # Store keys in MacOS Keychain, Windows Credential Locker
 packaging = "24.0"
 pip = "24.0"
 psutil = [
@@ -111,7 +111,7 @@ pyupgrade = { version = "3.15.2", optional = true }
 
 
 [tool.poetry.extras]
-dev = ["aiohttp_cors", "black", "build", "coverage", "diff-cover", "flake8", "isort", "mypy", "pre-commit", "py3createtorrent", "pyinstaller", "pylint", "pytest", "pytest-cov", "pytest-mock", "pytest-monitor", "pytest-xdist", "twine", "types-aiofiles", "types-cryptography", "types-pyyaml", "types-setuptools", "pyupgrade", "lxml"]
+dev = ["aiohttp_cors", "black", "build", "coverage", "diff-cover", "flake8", "isort", "mypy", "pre-commit", "py3createtorrent", "pyinstaller", "pylint", "pytest", "pytest-cov", "pytest-mock", "pytest-monitor", "pytest-xdist", "types-aiofiles", "types-cryptography", "types-pyyaml", "types-setuptools", "pyupgrade", "lxml"]
 upnp = ["miniupnpc"]
 legacy_keyring = ["keyrings.cryptfile"]