chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/full_node/weight_proof.py

@@ -8,7 +8,7 @@ import random
 import tempfile
 from concurrent.futures.process import ProcessPoolExecutor
 from multiprocessing.context import BaseContext
-from typing import IO, Optional
+from typing import IO
 
 from chia_rs import (
     BlockRecord,
@@ -30,7 +30,7 @@ from chia.consensus.block_header_validation import validate_finished_header_bloc
 from chia.consensus.blockchain_interface import BlockchainInterface
 from chia.consensus.deficit import calculate_deficit
 from chia.consensus.full_block_to_block_record import header_block_to_sub_block_record
-from chia.consensus.get_block_challenge import prev_tx_block
+from chia.consensus.get_block_challenge import pre_sp_tx_block_height
 from chia.consensus.pot_iterations import (
     calculate_ip_iters,
     calculate_sp_iters,
@@ -67,24 +67,24 @@ class WeightProofHandler:
         self,
         constants: ConsensusConstants,
         blockchain: BlockchainInterface,
-        multiprocessing_context: Optional[BaseContext] = None,
+        multiprocessing_context: BaseContext | None = None,
     ):
-        self.tip: Optional[bytes32] = None
-        self.proof: Optional[WeightProof] = None
+        self.tip: bytes32 | None = None
+        self.proof: WeightProof | None = None
         self.constants = constants
         self.blockchain = blockchain
         self.lock = asyncio.Lock()
         self._num_processes = 4
         self.multiprocessing_context = multiprocessing_context
 
-    async def get_proof_of_weight(self, tip: bytes32) -> Optional[WeightProof]:
+    async def get_proof_of_weight(self, tip: bytes32) -> WeightProof | None:
         tip_rec = self.blockchain.try_block_record(tip)
         if tip_rec is None:
             log.error("unknown tip")
             return None
 
         if tip_rec.height < self.constants.WEIGHT_PROOF_RECENT_BLOCKS:
-            log.debug("chain to short for weight proof")
+            log.info(f"chain to short for weight proof. tip: {tip_rec.height}")
             return None
 
         async with self.lock:
@@ -108,7 +108,7 @@ class WeightProofHandler:
             sub_epoch_data.append(_create_sub_epoch_data(ses))
         return sub_epoch_data
 
-    async def _create_proof_of_weight(self, tip: bytes32) -> Optional[WeightProof]:
+    async def _create_proof_of_weight(self, tip: bytes32) -> WeightProof | None:
         """
         Creates a weight proof object
         """
@@ -124,6 +124,10 @@ class WeightProofHandler:
             return None
 
         summary_heights = self.blockchain.get_ses_heights()
+        if len(summary_heights) <= 1:
+            log.error("not enough sub epochs. perhaps WEIGHT_PROOF_RECENT_BLOCKS is too small")
+            return None
+
         zero_hash = self.blockchain.height_to_hash(uint32(0))
         assert zero_hash is not None
         prev_ses_block = await self.blockchain.get_block_record_from_db(zero_hash)
@@ -183,7 +187,7 @@ class WeightProofHandler:
         seed = ses.get_hash()
         return seed
 
-    async def _get_recent_chain(self, tip_height: uint32) -> Optional[list[HeaderBlock]]:
+    async def _get_recent_chain(self, tip_height: uint32) -> list[HeaderBlock] | None:
         recent_chain: list[HeaderBlock] = []
         ses_heights = self.blockchain.get_ses_heights()
         min_height = 0
@@ -256,10 +260,10 @@ class WeightProofHandler:
             return None
 
         summary_heights = self.blockchain.get_ses_heights()
-        h_hash: Optional[bytes32] = self.blockchain.height_to_hash(uint32(0))
+        h_hash: bytes32 | None = self.blockchain.height_to_hash(uint32(0))
         if h_hash is None:
             return None
-        prev_ses_block: Optional[BlockRecord] = await self.blockchain.get_block_record_from_db(h_hash)
+        prev_ses_block: BlockRecord | None = await self.blockchain.get_block_record_from_db(h_hash)
         if prev_ses_block is None:
             return None
 
@@ -294,7 +298,7 @@ class WeightProofHandler:
 
     async def __create_sub_epoch_segments(
         self, ses_block: BlockRecord, se_start: BlockRecord, sub_epoch_n: uint32
-    ) -> Optional[list[SubEpochChallengeSegment]]:
+    ) -> list[SubEpochChallengeSegment] | None:
         segments: list[SubEpochChallengeSegment] = []
         start_height = await self.get_prev_two_slots_height(se_start)
 
@@ -304,7 +308,7 @@ class WeightProofHandler:
         header_blocks = await self.blockchain.get_header_blocks_in_range(
             start_height, ses_block.height + self.constants.MAX_SUB_SLOT_BLOCKS, tx_filter=False
         )
-        curr: Optional[HeaderBlock] = header_blocks[se_start.header_hash]
+        curr: HeaderBlock | None = header_blocks[se_start.header_hash]
         height = se_start.height
         assert curr is not None
         first = True
@@ -354,7 +358,7 @@ class WeightProofHandler:
         header_blocks: dict[bytes32, HeaderBlock],
         blocks: dict[bytes32, BlockRecord],
         first_segment_in_sub_epoch: bool,
-    ) -> tuple[Optional[SubEpochChallengeSegment], uint32]:
+    ) -> tuple[SubEpochChallengeSegment | None, uint32]:
         assert self.blockchain is not None
         sub_slots: list[SubSlotData] = []
         log.debug(f"create challenge segment block {header_block.header_hash} block height {header_block.height} ")
@@ -401,7 +405,7 @@ class WeightProofHandler:
         header_blocks: dict[bytes32, HeaderBlock],
         blocks: dict[bytes32, BlockRecord],
         first_in_sub_epoch: bool,
-    ) -> tuple[Optional[list[SubSlotData]], Optional[VDFInfo]]:
+    ) -> tuple[list[SubSlotData] | None, VDFInfo | None]:
         # combine cc vdfs of all reward blocks from the start of the sub slot to end
         header_block_sub_rec = blocks[header_block.header_hash]
         # find slot start
@@ -476,7 +480,7 @@ class WeightProofHandler:
         header_block: HeaderBlock,
         blocks: dict[bytes32, BlockRecord],
         header_blocks: dict[bytes32, HeaderBlock],
-    ) -> Optional[VDFInfo]:
+    ) -> VDFInfo | None:
         curr = blocks[header_block.header_hash]
         while curr.height > 0 and not curr.sub_epoch_summary_included:
             curr = blocks[curr.prev_hash]
@@ -484,7 +488,7 @@ class WeightProofHandler:
 
     async def __slot_end_vdf(
         self, start_height: uint32, header_blocks: dict[bytes32, HeaderBlock], blocks: dict[bytes32, BlockRecord]
-    ) -> tuple[Optional[list[SubSlotData]], uint32]:
+    ) -> tuple[list[SubSlotData] | None, uint32]:
         # gets all vdfs first sub slot after challenge block to last sub slot
         log.debug(f"slot end vdf start height {start_height}")
         header_hash = self.blockchain.height_to_hash(start_height)
@@ -659,7 +663,7 @@ class WeightProofHandler:
 
 def _get_weights_for_sampling(
     rng: random.Random, total_weight: uint128, recent_chain: list[HeaderBlock]
-) -> Optional[list[uint128]]:
+) -> list[uint128] | None:
     weight_to_check = []
     last_l_weight = recent_chain[-1].reward_chain_block.weight - recent_chain[0].reward_chain_block.weight
     delta = last_l_weight / total_weight
@@ -680,7 +684,7 @@ def _get_weights_for_sampling(
 def _sample_sub_epoch(
     start_of_epoch_weight: uint128,
     end_of_epoch_weight: uint128,
-    weight_to_check: Optional[list[uint128]],
+    weight_to_check: list[uint128] | None,
 ) -> bool:
     """
     weight_to_check: list[uint128] is expected to be sorted
@@ -715,7 +719,7 @@ def _create_sub_epoch_data(
     #  New work difficulty and iterations per sub-slot
     sub_slot_iters = sub_epoch_summary.new_sub_slot_iters
     new_difficulty = sub_epoch_summary.new_difficulty
-    return SubEpochData(reward_chain_hash, previous_sub_epoch_overflows, sub_slot_iters, new_difficulty)
+    return SubEpochData(reward_chain_hash, previous_sub_epoch_overflows, sub_slot_iters, new_difficulty, None)
 
 
 async def _challenge_block_vdfs(
@@ -762,7 +766,7 @@ async def _challenge_block_vdfs(
     return ssd
 
 
-def handle_finished_slots(end_of_slot: EndOfSubSlotBundle, icc_end_of_slot_info: Optional[VDFInfo]) -> SubSlotData:
+def handle_finished_slots(end_of_slot: EndOfSubSlotBundle, icc_end_of_slot_info: VDFInfo | None) -> SubSlotData:
     return SubSlotData(
         None,
         None,
@@ -833,7 +837,7 @@ def handle_end_of_slot(
 def _validate_sub_epoch_summaries(
     constants: ConsensusConstants,
     weight_proof: WeightProof,
-) -> tuple[Optional[list[SubEpochSummary]], Optional[list[uint128]]]:
+) -> tuple[list[SubEpochSummary] | None, list[uint128] | None]:
     last_ses_hash, last_ses_sub_height = _get_last_ses_hash(constants, weight_proof.recent_chain_data)
     if last_ses_hash is None:
         log.warning("could not find last ses block")
@@ -879,6 +883,7 @@ def _map_sub_epoch_summaries(
             data.num_blocks_overflow,
             data.new_difficulty,
             data.new_sub_slot_iters,
+            None,
         )
 
         if idx < len(sub_epoch_data) - 1:
@@ -929,14 +934,14 @@ def _validate_sub_epoch_segments(
     summaries_bytes: list[bytes],
     height: uint32,
     validate_from: int = 0,
-) -> Optional[list[tuple[VDFProof, ClassgroupElement, VDFInfo]]]:
+) -> list[tuple[VDFProof, ClassgroupElement, VDFInfo]] | None:
     summaries = summaries_from_bytes(summaries_bytes)
     sub_epoch_segments: SubEpochSegments = SubEpochSegments.from_bytes(weight_proof_bytes)
     rc_sub_slot_hash = constants.GENESIS_CHALLENGE
     total_blocks, total_ip_iters = 0, 0
     total_slot_iters, total_slots = 0, 0
     total_ip_iters = 0
-    prev_ses: Optional[SubEpochSummary] = None
+    prev_ses: SubEpochSummary | None = None
     segments_by_sub_epoch = map_segments_by_sub_epoch(sub_epoch_segments.challenge_segments)
     curr_ssi = constants.SUB_SLOT_ITERS_STARTING
     vdfs_to_validate = []
@@ -988,7 +993,7 @@ def _validate_segment(
     curr_ssi: uint64,
     prev_ssi: uint64,
     curr_difficulty: uint64,
-    ses: Optional[SubEpochSummary],
+    ses: SubEpochSummary | None,
     first_segment_in_se: bool,
     sampled: bool,
     height: uint32,
@@ -1000,7 +1005,7 @@ def _validate_segment(
         if sampled and sub_slot_data.is_challenge():
             after_challenge = True
             required_iters = __validate_pospace(
-                constants, segment, idx, curr_difficulty, curr_ssi, ses, first_segment_in_se, height
+                constants, segment, idx, curr_difficulty, ses, first_segment_in_se, height
             )
             if required_iters is None:
                 return False, uint64(0), uint64(0), uint64(0), []
@@ -1144,7 +1149,7 @@ def sub_slot_data_vdf_input(
 ) -> ClassgroupElement:
     cc_input = ClassgroupElement.get_default_element()
     sp_total_iters = get_sp_total_iters(constants, is_overflow, ssi, sub_slot_data)
-    ssd: Optional[SubSlotData] = None
+    ssd: SubSlotData | None = None
     if is_overflow and new_sub_slot:
         if sub_slot_idx >= 2:
             if sub_slots[sub_slot_idx - 2].cc_slot_end_info is None:
@@ -1202,7 +1207,7 @@ def validate_recent_blocks(
     constants: ConsensusConstants,
     recent_chain_bytes: bytes,
     summaries_bytes: list[bytes],
-    shutdown_file_path: Optional[pathlib.Path] = None,
+    shutdown_file_path: pathlib.Path | None = None,
 ) -> tuple[bool, list[bytes]]:
     recent_chain: RecentChainData = RecentChainData.from_bytes(recent_chain_bytes)
     summaries = summaries_from_bytes(summaries_bytes)
@@ -1221,7 +1226,7 @@ def validate_recent_blocks(
     ses_blocks, sub_slots, transaction_blocks = 0, 0, 0
     challenge, prev_challenge = recent_chain.recent_chain_data[0].reward_chain_block.pos_ss_cc_challenge_hash, None
     tip_height = recent_chain.recent_chain_data[-1].height
-    prev_block_record: Optional[BlockRecord] = None
+    prev_block_record: BlockRecord | None = None
     deficit = uint8(0)
     adjusted = False
     validated_block_count = 0
@@ -1245,7 +1250,9 @@ def validate_recent_blocks(
             if sub_slot.challenge_chain.new_difficulty is not None:
                 diff = sub_slot.challenge_chain.new_difficulty
 
-        if (challenge is not None) and (prev_challenge is not None) and transaction_blocks > 1:
+        # we need at least two challenges and more than 2 transaction blocks in the cache to validate pospace
+        # otherwise we might fail to validate due to lack of information
+        if (challenge is not None) and (prev_challenge is not None) and transaction_blocks > 2:
             overflow = is_overflow_block(constants, block.reward_chain_block.signage_point_index)
             if not adjusted:
                 assert prev_block_record is not None
@@ -1267,7 +1274,7 @@ def validate_recent_blocks(
                 required_iters = caluclated_required_iters
             else:
                 ret = _validate_pospace_recent_chain(
-                    constants, sub_blocks, block, challenge, diff, ssi, overflow, prev_challenge
+                    constants, sub_blocks, block, challenge, diff, overflow, prev_challenge
                 )
                 if ret is None:
                     return False, []
@@ -1310,10 +1317,9 @@ def _validate_pospace_recent_chain(
     block: HeaderBlock,
     challenge: bytes32,
     diff: uint64,
-    ssi: uint64,
     overflow: bool,
     prev_challenge: bytes32,
-) -> Optional[uint64]:
+) -> uint64 | None:
     if block.reward_chain_block.challenge_chain_sp_vdf is None:
         # Edge case of first sp (start of slot), where sp_iters == 0
         cc_sp_hash: bytes32 = challenge
@@ -1328,8 +1334,13 @@ def _validate_pospace_recent_chain(
         cc_sp_hash,
         block.height,
         diff,
-        ssi,
-        prev_tx_block(blocks, blocks.block_record(block.prev_header_hash)),
+        pre_sp_tx_block_height(
+            constants=constants,
+            blocks=blocks,
+            prev_b_hash=block.prev_header_hash,
+            sp_index=block.reward_chain_block.signage_point_index,
+            finished_sub_slots=len(block.finished_sub_slots),
+        ),
     )
     if required_iters is None:
         log.error(f"could not verify proof of space block {block.height} {overflow}")
@@ -1343,11 +1354,10 @@ def __validate_pospace(
     segment: SubEpochChallengeSegment,
     idx: int,
     curr_diff: uint64,
-    curr_sub_slot_iters: uint64,
-    ses: Optional[SubEpochSummary],
+    ses: SubEpochSummary | None,
     first_in_sub_epoch: bool,
     height: uint32,
-) -> Optional[uint64]:
+) -> uint64 | None:
     if first_in_sub_epoch and segment.sub_epoch_n == 0 and idx == 0:
         cc_sub_slot_hash = constants.GENESIS_CHALLENGE
     else:
@@ -1370,6 +1380,9 @@ def __validate_pospace(
     # validate proof of space
     assert sub_slot_data.proof_of_space is not None
 
+    # when sampling blocks as part of weight proof validation, the previous
+    # transaction height is a conservative estimate, since we don't have direct
+    # access to it.
     required_iters = validate_pospace_and_get_required_iters(
         constants,
         sub_slot_data.proof_of_space,
@@ -1377,8 +1390,8 @@ def __validate_pospace(
         cc_sp_hash,
         height,
         curr_diff,
-        curr_sub_slot_iters,
-        uint32(0),  # prev_tx_block(blocks, prev_b), todo need to get height of prev tx block somehow here
+        uint32(0),  # not used, since height_agnostic=True
+        height_agnostic=True,
     )
     if required_iters is None:
         log.error("could not verify proof of space")
@@ -1417,7 +1430,7 @@ def __get_rc_sub_slot(
 
     new_diff = None if ses is None else ses.new_difficulty
     new_ssi = None if ses is None else ses.new_sub_slot_iters
-    ses_hash: Optional[bytes32] = None if ses is None else ses.get_hash()
+    ses_hash: bytes32 | None = None if ses is None else ses.get_hash()
     overflow = is_overflow_block(constants, first.signage_point_index)
     if overflow:
         if idx >= 2 and slots[idx - 2].cc_slot_end is not None and slots[idx - 1].cc_slot_end is not None:
@@ -1434,7 +1447,7 @@ def __get_rc_sub_slot(
         idx -= 1
         sub_slot = slots[idx]
 
-    icc_sub_slot_hash: Optional[bytes32] = None
+    icc_sub_slot_hash: bytes32 | None = None
     assert sub_slot is not None
     assert sub_slot.cc_slot_end_info is not None
 
@@ -1471,8 +1484,8 @@ def __get_rc_sub_slot(
     return rc_sub_slot
 
 
-def __get_cc_sub_slot(sub_slots: list[SubSlotData], idx: int, ses: Optional[SubEpochSummary]) -> ChallengeChainSubSlot:
-    sub_slot: Optional[SubSlotData] = None
+def __get_cc_sub_slot(sub_slots: list[SubSlotData], idx: int, ses: SubEpochSummary | None) -> ChallengeChainSubSlot:
+    sub_slot: SubSlotData | None = None
     for i in reversed(range(idx)):
         sub_slot = sub_slots[i]
         if sub_slot.cc_slot_end_info is not None:
@@ -1482,7 +1495,7 @@ def __get_cc_sub_slot(sub_slots: list[SubSlotData], idx: int, ses: Optional[SubE
     assert sub_slot.cc_slot_end_info is not None
 
     icc_vdf = sub_slot.icc_slot_end_info
-    icc_vdf_hash: Optional[bytes32] = None
+    icc_vdf_hash: bytes32 | None = None
     if icc_vdf is not None:
         icc_vdf_hash = icc_vdf.get_hash()
     cc_sub_slot = ChallengeChainSubSlot(
@@ -1529,7 +1542,7 @@ def summaries_from_bytes(summaries_bytes: list[bytes]) -> list[SubEpochSummary]:
 
 def _get_last_ses_hash(
     constants: ConsensusConstants, recent_reward_chain: list[HeaderBlock]
-) -> tuple[Optional[bytes32], uint32]:
+) -> tuple[bytes32 | None, uint32]:
     for idx, block in enumerate(reversed(recent_reward_chain)):
         if (block.reward_chain_block.height % constants.SUB_EPOCH_BLOCKS) == 0:
             original_idx = len(recent_reward_chain) - 1 - idx  # reverse
@@ -1560,7 +1573,7 @@ def _get_ses_idx(recent_reward_chain: list[HeaderBlock]) -> list[int]:
 def get_deficit(
     constants: ConsensusConstants,
     curr_deficit: uint8,
-    prev_block: Optional[BlockRecord],
+    prev_block: BlockRecord | None,
     overflow: bool,
     num_finished_sub_slots: int,
 ) -> uint8:
@@ -1634,7 +1647,7 @@ def map_segments_by_sub_epoch(
 def _validate_vdf_batch(
     constants: ConsensusConstants,
     vdf_list: list[tuple[bytes, bytes, bytes]],
-    shutdown_file_path: Optional[pathlib.Path] = None,
+    shutdown_file_path: pathlib.Path | None = None,
 ) -> bool:
     for vdf_proof_bytes, class_group_bytes, info in vdf_list:
         vdf = VDFProof.from_bytes(vdf_proof_bytes)

chia/harvester/harvester.py

@@ -8,11 +8,10 @@ import logging
 from collections.abc import AsyncIterator
 from concurrent.futures.thread import ThreadPoolExecutor
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
 
 from chia_rs import ConsensusConstants
-from chia_rs.sized_ints import uint32
-from typing_extensions import Literal
+from chia_rs.sized_ints import uint8, uint32
 
 from chia.plot_sync.sender import Sender
 from chia.plotting.manager import PlotManager
@@ -56,11 +55,11 @@ class Harvester:
     root_path: Path
     _shut_down: bool
     executor: ThreadPoolExecutor
-    state_changed_callback: Optional[StateChangedProtocol] = None
+    state_changed_callback: StateChangedProtocol | None = None
     constants: ConsensusConstants
     _refresh_lock: asyncio.Lock
     event_loop: asyncio.events.AbstractEventLoop
-    _server: Optional[ChiaServer]
+    _server: ChiaServer | None
     _mode: HarvestingMode
 
     @property
@@ -91,7 +90,10 @@ class Harvester:
         self.log.info(f"Using plots_refresh_parameter: {refresh_parameter}")
 
         self.plot_manager = PlotManager(
-            root_path, refresh_parameter=refresh_parameter, refresh_callback=self._plot_refresh_callback
+            root_path,
+            refresh_parameter=refresh_parameter,
+            refresh_callback=self._plot_refresh_callback,
+            constants=constants,
         )
         self._shut_down = False
         self.executor = concurrent.futures.ThreadPoolExecutor(
@@ -99,7 +101,7 @@ class Harvester:
         )
         self._server = None
         self.constants = constants
-        self.state_changed_callback: Optional[StateChangedProtocol] = None
+        self.state_changed_callback: StateChangedProtocol | None = None
         self.parallel_read: bool = config.get("parallel_read", True)
 
         context_count = config.get("parallel_decompressor_count", DEFAULT_PARALLEL_DECOMPRESSOR_COUNT)
@@ -148,7 +150,7 @@ class Harvester:
 
             await self.plot_sync_sender.await_closed()
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def on_connect(self, connection: WSChiaConnection) -> None:
@@ -157,7 +159,7 @@ class Harvester:
     def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
         self.state_changed_callback = callback
 
-    def state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> None:
+    def state_changed(self, change: str, change_data: dict[str, Any] | None = None) -> None:
         if self.state_changed_callback is not None:
             self.state_changed_callback(change, change_data)
 
@@ -190,13 +192,12 @@ class Harvester:
         with self.plot_manager:
             for path, plot_info in self.plot_manager.plots.items():
                 prover = plot_info.prover
-                size = prover.get_size()
-                if size.size_v1 is not None:
-                    k = size.size_v1
+                param = prover.get_param()
+                if param.size_v1 is not None:
+                    k = uint8(param.size_v1)
                 else:
-                    assert size.size_v2 is not None
-                    k = size.size_v2
-                    # TODO: todo_v2_plots support v2 plots in RPC response
+                    assert param.strength_v2 is not None
+                    k = uint8(0x80 | param.strength_v2)
                 response_plots.append(
                     {
                         "filename": str(path),
@@ -246,16 +247,16 @@ class Harvester:
     async def update_harvester_config(
         self,
         *,
-        use_gpu_harvesting: Optional[bool] = None,
-        gpu_index: Optional[int] = None,
-        enforce_gpu_index: Optional[bool] = None,
-        disable_cpu_affinity: Optional[bool] = None,
-        parallel_decompressor_count: Optional[int] = None,
-        decompressor_thread_count: Optional[int] = None,
-        recursive_plot_scan: Optional[bool] = None,
-        refresh_parameter_interval_seconds: Optional[uint32] = None,
+        use_gpu_harvesting: bool | None = None,
+        gpu_index: int | None = None,
+        enforce_gpu_index: bool | None = None,
+        disable_cpu_affinity: bool | None = None,
+        parallel_decompressor_count: int | None = None,
+        decompressor_thread_count: int | None = None,
+        recursive_plot_scan: bool | None = None,
+        refresh_parameter_interval_seconds: uint32 | None = None,
     ) -> bool:
-        refresh_parameter: Optional[PlotsRefreshParameter] = None
+        refresh_parameter: PlotsRefreshParameter | None = None
         if refresh_parameter_interval_seconds is not None:
             refresh_parameter = PlotsRefreshParameter(
                 interval_seconds=refresh_parameter_interval_seconds,