basedpyright complains a lot..

Author: robamu

src/cfdppy/handler/dest.py

@@ -5,7 +5,7 @@
 from collections import deque
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING 
 
 from spacepackets.cfdp import (
     ChecksumType,
@@ -83,7 +83,7 @@ class _DestFileParams(_FileParamsBase):
     file_name: Path
 
     @classmethod
-    def empty(cls) -> _DestFileParams:
+    def empty(cls) -> _DestFileParams: # pyright: ignore[reportImplicitOverride]
         return cls(
             progress=0,
             segment_len=0,
@@ -93,7 +93,7 @@ def empty(cls) -> _DestFileParams:
             metadata_only=False,
         )
 
-    def reset(self) -> None:
+    def reset(self) -> None: # pyright: ignore[reportImplicitOverride]
         super().reset()
         self.file_name = Path()
 
@@ -146,7 +146,7 @@ def packets_ready(self) -> bool:
 
 class LostSegmentTracker:
     def __init__(self):
-        self.lost_segments = {}
+        self.lost_segments: dict[int, int] = {}
 
     @property
     def num_lost_segments(self) -> int:
@@ -162,7 +162,7 @@ def add_lost_segment(self, lost_seg: tuple[int, int]) -> None:
     def coalesce_lost_segments(self) -> None:
         if len(self.lost_segments) <= 1:
             return
-        merged_segments = []
+        merged_segments: list[tuple[int, int]] = []
         # Initialize to the first entry.
         current_start, current_end = next(iter(self.lost_segments.items()))
 
@@ -248,16 +248,16 @@ def __init__(self):
             condition_code=ConditionCode.NO_ERROR,
         )
         self.completion_disposition: CompletionDisposition = CompletionDisposition.COMPLETED
-        self.pdu_conf = PduConfig.empty()
+        self.pdu_conf: PduConfig = PduConfig.empty()
         self.fp: _DestFileParams = _DestFileParams.empty()
 
-        self.acked_params = _AckedModeParams()
-        self.positive_ack_params = _PositiveAckProcedureParams()
+        self.acked_params: _AckedModeParams = _AckedModeParams()
+        self.positive_ack_params: _PositiveAckProcedureParams = _PositiveAckProcedureParams()
 
 
 class FsmResult:
     def __init__(self, states: DestStateWrapper):
-        self.states = states
+        self.states: DestStateWrapper = states
 
 
 def acknowledge_inactive_eof_pdu(eof_pdu: EofPdu, status: TransactionStatus) -> AckPdu:
@@ -323,12 +323,12 @@ def __init__(
         remote_cfg_table: RemoteEntityConfigTable,
         check_timer_provider: CheckTimerProvider,
     ) -> None:
-        self.cfg = cfg
-        self.remote_cfg_table = remote_cfg_table
-        self.states = DestStateWrapper()
-        self.user = user
-        self.check_timer_provider = check_timer_provider
-        self._params = _DestFieldWrapper()
+        self.cfg: LocalEntityConfig = cfg
+        self.remote_cfg_table: RemoteEntityConfigTable = remote_cfg_table
+        self.states: DestStateWrapper = DestStateWrapper()
+        self.user: CfdpUserBase = user
+        self.check_timer_provider: CheckTimerProvider = check_timer_provider
+        self._params: _DestFieldWrapper = _DestFieldWrapper()
         self._pdus_to_be_sent: deque[PduHolder] = deque()
 
     @property
@@ -684,6 +684,7 @@ def _common_first_packet_handler(self, pdu: GenericPduPacket) -> bool | None:
         return None
 
     def _handle_metadata_packet(self, metadata_pdu: MetadataPdu) -> None:
+        assert self._params.transaction_id is not None
         self._params.checksum_type = metadata_pdu.checksum_type
         self._params.closure_requested = metadata_pdu.closure_requested
         self._params.acked_params.metadata_missing = False
@@ -703,10 +704,11 @@ def _handle_metadata_packet(self, metadata_pdu: MetadataPdu) -> None:
             raise NoRemoteEntityConfigFound(metadata_pdu.dest_entity_id)
         if not self._params.fp.metadata_only:
             self.states.step = TransactionStep.RECEIVING_FILE_DATA
-            self._init_vfs_handling(Path(metadata_pdu.source_file_name).name)  # type: ignore
+            assert metadata_pdu.source_file_name is not None
+            self._init_vfs_handling(Path(metadata_pdu.source_file_name).name)
         else:
             self.states.step = TransactionStep.TRANSFER_COMPLETION
-        msgs_to_user_list = None
+        msgs_to_user_list: None | list[MessageToUserTlv] = None
         options = metadata_pdu.options_as_tlv()
         if options is not None:
             msgs_to_user_list = []
@@ -717,7 +719,7 @@ def _handle_metadata_packet(self, metadata_pdu: MetadataPdu) -> None:
             None if metadata_pdu.source_file_name is None else metadata_pdu.file_size
         )
         params = MetadataRecvParams(
-            transaction_id=self._params.transaction_id,  # type: ignore
+            transaction_id=self._params.transaction_id,
             file_size=file_size_for_indication,
             source_id=metadata_pdu.source_entity_id,
             dest_file_name=metadata_pdu.dest_file_name,
@@ -848,11 +850,11 @@ def _handle_fd_pdu(self, file_data_pdu: FileDataPdu) -> None:
         except FileNotFoundError:
             if self._params.finished_params.file_status != FileStatus.FILE_RETAINED:
                 self._params.finished_params.file_status = FileStatus.DISCARDED_FILESTORE_REJECTION
-                self._declare_fault(ConditionCode.FILESTORE_REJECTION)
+                _ = self._declare_fault(ConditionCode.FILESTORE_REJECTION)
         except PermissionError:
             if self._params.finished_params.file_status != FileStatus.FILE_RETAINED:
                 self._params.finished_params.file_status = FileStatus.DISCARDED_FILESTORE_REJECTION
-                self._declare_fault(ConditionCode.FILESTORE_REJECTION)
+                _ = self._declare_fault(ConditionCode.FILESTORE_REJECTION)
 
     def _handle_transfer_completion(self) -> None:
         self._notice_of_completion()
@@ -887,7 +889,7 @@ def _lost_segment_handling(self, offset: int, data_len: int) -> None:
             self._params.acked_params.last_end_offset = offset + data_len
         if offset + data_len <= self._params.acked_params.last_start_offset:
             # Might be a re-requested FD PDU.
-            self._params.acked_params.lost_seg_tracker.remove_lost_segment(
+            _ = self._params.acked_params.lost_seg_tracker.remove_lost_segment(
                 (offset, offset + data_len)
             )
 
@@ -973,7 +975,7 @@ def _handle_eof_pdu(self, eof_pdu: EofPdu) -> None:
             assert self._params.transaction_id is not None
             self.user.eof_recv_indication(self._params.transaction_id)
         if eof_pdu.condition_code == ConditionCode.NO_ERROR:
-            regular_completion = self._handle_eof_no_error()
+            regular_completion = self._handle_eof_no_error(eof_pdu.file_checksum)
             if not regular_completion:
                 return
         else:
@@ -985,6 +987,7 @@ def _handle_eof_pdu(self, eof_pdu: EofPdu) -> None:
             self._eof_ack_pdu_done()
 
     def _handle_eof_cancel(self, eof_pdu: EofPdu) -> None:
+        assert self._params.remote_cfg is not None
         # This is an EOF (Cancel), perform Cancel Response Procedures according to chapter
         # 4.6.6 of the standard. Set remote ID as fault location.
         self._trigger_notice_of_completion_canceled(
@@ -1000,29 +1003,29 @@ def _handle_eof_cancel(self, eof_pdu: EofPdu) -> None:
             # Empty file, no file data PDU.
             self._params.finished_params.delivery_code = DeliveryCode.DATA_COMPLETE
             return
-        if self._checksum_verify(self._params.fp.progress, self._params.fp.crc32):
+        if self._checksum_verify(self._params.fp.progress, eof_pdu.file_checksum):
             self._params.finished_params.delivery_code = DeliveryCode.DATA_COMPLETE
             return
         self._params.finished_params.delivery_code = DeliveryCode.DATA_INCOMPLETE
 
-    def _handle_eof_no_error(self) -> bool:
+    def _handle_eof_no_error(self, crc32: bytes) -> bool:
         """Returns whether the transfer can be completed regularly."""
+        assert self._params.fp.file_size is not None
         # CFDP 4.6.1.2.9: Declare file size error if progress exceeds file size
-        if self._params.fp.progress > self._params.fp.file_size:  # type: ignore
+        if self._params.fp.progress > self._params.fp.file_size:
             if self._declare_fault(ConditionCode.FILE_SIZE_ERROR) != FaultHandlerCode.IGNORE_ERROR:
                 return False
         elif (
-            self._params.fp.progress < self._params.fp.file_size  # type: ignore
+            self._params.fp.progress < self._params.fp.file_size
         ) and self.transmission_mode == TransmissionMode.ACKNOWLEDGED:
             # CFDP 4.6.4.3.1: The end offset of the last received file segment and the file
             # size as stated in the EOF PDU is not the same, so we need to add that segment to
             # the lost segments for the deferred lost segment detection procedure.
             self._params.acked_params.lost_seg_tracker.add_lost_segment(
                 (self._params.fp.progress, self._params.fp.file_size)  # type: ignore
             )
-        if (
-            self.transmission_mode == TransmissionMode.UNACKNOWLEDGED
-            and not self._checksum_verify(self._params.fp.progress, self._params.fp.crc32)  # type: ignore
+        if self.transmission_mode == TransmissionMode.UNACKNOWLEDGED and not self._checksum_verify(
+            self._params.fp.progress, crc32
         ):
             self._start_check_limit_handling()
             return False
@@ -1031,14 +1034,15 @@ def _handle_eof_no_error(self) -> bool:
         return True
 
     def _start_deferred_lost_segment_handling(self) -> None:
+        assert self._params.fp.file_size is not None
         if self._params.acked_params.metadata_missing:
             self.states.step = TransactionStep.WAITING_FOR_METADATA
         else:
             self.states.step = TransactionStep.WAITING_FOR_MISSING_DATA
         self._params.acked_params.deferred_lost_segment_detection_active = True
         self._params.acked_params.lost_seg_tracker.coalesce_lost_segments()
-        self._params.acked_params.last_start_offset = self._params.fp.file_size  # type: ignore
-        self._params.acked_params.last_end_offset = self._params.fp.file_size  # type: ignore
+        self._params.acked_params.last_start_offset = self._params.fp.file_size
+        self._params.acked_params.last_end_offset = self._params.fp.file_size
         self._deferred_lost_segment_handling()
 
     def _prepare_eof_ack_packet(self) -> None:
@@ -1084,6 +1088,7 @@ def _start_check_limit_handling(self) -> None:
         self._params.current_check_count = 0
 
     def _notice_of_completion(self) -> None:
+        assert self._params.transaction_id is not None
         if self._params.completion_disposition == CompletionDisposition.COMPLETED:
             # TODO: Execute any filestore requests
             pass
@@ -1097,7 +1102,7 @@ def _notice_of_completion(self) -> None:
                 self._params.finished_params.file_status = FileStatus.DISCARDED_DELIBERATELY
         if self.cfg.indication_cfg.transaction_finished_indication_required:
             finished_indic_params = TransactionFinishedParams(
-                transaction_id=self._params.transaction_id,  # type: ignore
+                transaction_id=self._params.transaction_id,
                 finished_params=self._params.finished_params,
                 status_report=None,
             )