SYMBOL INDEX (524 symbols across 72 files)

FILE: backend/control/strategies.py
  class ControlStrategy (line 4) | class ControlStrategy(ABC):
    method update (line 8) | def update(self, model, dt: float, axes: Dict[str, float]) -> None:
  class IncrementalStrategy (line 13) | class IncrementalStrategy(ControlStrategy):
    method update (line 14) | def update(self, model, dt, axes):
  class DirectStrategy (line 19) | class DirectStrategy(ControlStrategy):
    method update (line 24) | def update(self, model, dt, axes):

FILE: backend/main.py
  function main (line 44) | def main():

FILE: backend/models/base_rc.py
  class BaseRCModel (line 10) | class BaseRCModel(ABC):
    method __init__ (line 25) | def __init__(
    method update (line 57) | def update(self, dt, axes): ...
    method takeoff (line 59) | def takeoff(self): ...
    method land (line 61) | def land(self): ...
    method get_control_state (line 63) | def get_control_state(self): ...
    method set_profile (line 66) | def set_profile(self, name: str) -> None:
    method set_sensitivity (line 71) | def set_sensitivity(self, preset: int) -> None:
    method set_strategy (line 75) | def set_strategy(self, strategy) -> None:
    method _apply_profile (line 79) | def _apply_profile(self, profile: ControlProfile) -> None:
    method _scale_normalised (line 90) | def _scale_normalised(self, value: float) -> float:
    method _update_axes_incremental (line 99) | def _update_axes_incremental(self, dt, axes):
    method update_axes (line 108) | def update_axes(self, dt, throttle_dir, yaw_dir, pitch_dir, roll_dir):
    method _update_axes_direct (line 172) | def _update_axes_direct(self, axes):

FILE: backend/models/base_video_model.py
  class BaseVideoModel (line 5) | class BaseVideoModel(ABC):
    method ingest_chunk (line 13) | def ingest_chunk(

FILE: backend/models/control_profile.py
  class ControlProfile (line 4) | class ControlProfile:

FILE: backend/models/cooingdv_rc.py
  class CooingdvRcModel (line 22) | class CooingdvRcModel(BaseRCModel):
    method __init__ (line 46) | def __init__(self, profile: str | ControlProfile = "normal") -> None:
    method update (line 68) | def update(self, dt, axes):
    method takeoff (line 71) | def takeoff(self):
    method land (line 75) | def land(self):
    method emergency_stop (line 84) | def emergency_stop(self):
    method flip (line 93) | def flip(self):
    method toggle_headless (line 97) | def toggle_headless(self):
    method calibrate_gyro (line 101) | def calibrate_gyro(self):
    method get_control_state (line 105) | def get_control_state(self):
    method set_strategy (line 114) | def set_strategy(self, strategy) -> None:

FILE: backend/models/cooingdv_video_model.py
  class CooingdvVideoModel (line 18) | class CooingdvVideoModel(BaseVideoModel):
    method __init__ (line 27) | def __init__(self):
    method ingest_chunk (line 30) | def ingest_chunk(
    method reset (line 67) | def reset(self) -> None:

FILE: backend/models/debug_rc.py
  class DebugRcModel (line 8) | class DebugRcModel(BaseRCModel):
    method __init__ (line 11) | def __init__(self):
    method update (line 17) | def update(self, dt, axes):
    method get_control_state (line 22) | def get_control_state(self):
    method set_throttle (line 32) | def set_throttle(self, value: int):
    method set_yaw (line 36) | def set_yaw(self, value: int):
    method set_pitch (line 40) | def set_pitch(self, value: int):
    method set_roll (line 44) | def set_roll(self, value: int):
    method takeoff (line 48) | def takeoff(self):
    method land (line 51) | def land(self):

FILE: backend/models/s2x_rc.py
  class S2xDroneModel (line 8) | class S2xDroneModel(BaseRCModel):
    method __init__ (line 19) | def __init__(self, profile: str | ControlProfile = "normal"):
    method update (line 42) | def update(self, dt, axes):
    method takeoff (line 45) | def takeoff(self):
    method land (line 49) | def land(self):
    method emergency_stop (line 59) | def emergency_stop(self):
    method set_speed_index (line 63) | def set_speed_index(self, speed_index: int) -> None:
    method get_control_state (line 67) | def get_control_state(self):
    method set_strategy (line 77) | def set_strategy(self, strategy) -> None:

FILE: backend/models/s2x_video_model.py
  class S2xVideoModel (line 7) | class S2xVideoModel(BaseVideoModel):
    method __init__ (line 18) | def __init__(self) -> None:
    method ingest_chunk (line 25) | def ingest_chunk(
    method _reset (line 63) | def _reset(self, new_fid: Optional[int]) -> None:
    method _assemble_current (line 67) | def _assemble_current(self, keys_to_use: set[int] | None = None) -> Op...

FILE: backend/models/stick_range.py
  class StickRange (line 4) | class StickRange:

FILE: backend/models/video_frame.py
  class VideoFrame (line 3) | class VideoFrame:
    method __init__ (line 6) | def __init__(self, frame_id, data, format_type="jpeg", timestamp=None):
    method __repr__ (line 15) | def __repr__(self):

FILE: backend/models/wifi_cam_rc.py
  class WifiCamRcModel (line 16) | class WifiCamRcModel(BaseRCModel):
    method __init__ (line 27) | def __init__(self, profile: str | ControlProfile = "normal") -> None:
    method update (line 44) | def update(self, dt, axes):
    method takeoff (line 47) | def takeoff(self):
    method land (line 50) | def land(self):
    method emergency_stop (line 53) | def emergency_stop(self):
    method flip (line 56) | def flip(self):
    method toggle_headless (line 59) | def toggle_headless(self):
    method toggle_altitude_hold (line 62) | def toggle_altitude_hold(self):
    method calibrate_gyro (line 65) | def calibrate_gyro(self):
    method get_control_state (line 68) | def get_control_state(self):
    method set_strategy (line 78) | def set_strategy(self, strategy) -> None:

FILE: backend/models/wifi_uav_rc.py
  class WifiUavRcModel (line 9) | class WifiUavRcModel(BaseRCModel):
    method __init__ (line 34) | def __init__(self, profile: str | ControlProfile = "normal") -> None:
    method update (line 58) | def update(self, dt, axes):          # type: ignore[override]
    method takeoff (line 61) | def takeoff(self):
    method land (line 64) | def land(self):
    method emergency_stop (line 68) | def emergency_stop(self):
    method flip (line 72) | def flip(self):
    method set_speed_index (line 76) | def set_speed_index(self, speed_index: int) -> None:
    method set_camera_tilt_state (line 80) | def set_camera_tilt_state(self, tilt_state: int) -> None:
    method toggle_record (line 85) | def toggle_record(self):             # type: ignore[override]
    method get_control_state (line 88) | def get_control_state(self):
    method set_strategy (line 99) | def set_strategy(self, strategy) -> None:

FILE: backend/models/wifi_uav_video_model.py
  class WifiUavVideoModel (line 8) | class WifiUavVideoModel:
    method __init__ (line 25) | def __init__(self, width: int = 640, height: int = 360, num_components...
    method ingest_chunk (line 35) | def ingest_chunk(self, payload: bytes) -> Optional[VideoFrame]:
    method _reset_state (line 79) | def _reset_state(self, new_frame_id: Optional[int]):

FILE: backend/plugins/base.py
  class Plugin (line 6) | class Plugin(ABC):
    method __init__ (line 14) | def __init__(self,
    method start (line 31) | def start(self):
    method stop (line 39) | def stop(self):
    method _on_start (line 50) | def _on_start(self):
    method _on_stop (line 53) | def _on_stop(self):
    method send_overlay (line 56) | def send_overlay(self, data: list):

FILE: backend/plugins/follow/follow_controller.py
  class FollowController (line 1) | class FollowController:
    method __init__ (line 9) | def __init__(
    method compute (line 29) | def compute(self, box_center_x: float, box_width: float) -> tuple[floa...

FILE: backend/plugins/follow/follow_plugin.py
  class FollowPlugin (line 16) | class FollowPlugin(Plugin):
    method _on_start (line 22) | def _on_start(self):
    method _on_stop (line 82) | def _on_stop(self):
    method _loop (line 95) | def _loop(self):

FILE: backend/plugins/follow/test_yolo.py
  function main (line 4) | def main():

FILE: backend/plugins/manager.py
  class PluginManager (line 13) | class PluginManager:
    method __init__ (line 14) | def __init__(self,
    method available (line 26) | def available(self) -> list[str]:
    method running (line 29) | def running(self) -> list[str]:
    method clear_overlays (line 32) | def clear_overlays(self) -> None:
    method start (line 43) | def start(self, name: str) -> bool:
    method stop (line 90) | def stop(self, name: str) -> bool:
    method stop_all (line 118) | def stop_all(self):
    method _discover_plugins (line 122) | def _discover_plugins(self):

FILE: backend/plugins/test_yaw_plugin.py
  class TestYawPlugin (line 9) | class TestYawPlugin(Plugin):
    method _on_start (line 21) | def _on_start(self):
    method _on_stop (line 46) | def _on_stop(self):
    method _run (line 72) | def _run(self):

FILE: backend/protocols/base_protocol_adapter.py
  class BaseProtocolAdapter (line 3) | class BaseProtocolAdapter(ABC):
    method build_control_packet (line 7) | def build_control_packet(self, drone_model):
    method send_control_packet (line 12) | def send_control_packet(self, packet):
    method toggle_debug (line 17) | def toggle_debug(self):

FILE: backend/protocols/base_video_protocol.py
  class BaseVideoProtocolAdapter (line 9) | class BaseVideoProtocolAdapter(ABC):
    method __init__ (line 15) | def __init__(self, drone_ip: str, control_port: int, video_port: int):
    method start_keepalive (line 22) | def start_keepalive(self, interval: float = 1.0) -> None:
    method stop_keepalive (line 34) | def stop_keepalive(self) -> None:
    method _keepalive_loop (line 40) | def _keepalive_loop(self, interval: float) -> None:
    method recv_from_socket (line 46) | def recv_from_socket(self, sock) -> Optional[bytes]:
    method send_start_command (line 60) | def send_start_command(self) -> None:
    method create_receiver_socket (line 65) | def create_receiver_socket(self) -> socket.socket:
    method handle_payload (line 70) | def handle_payload(self, payload: bytes) -> Optional[VideoFrame]:

FILE: backend/protocols/cooingdv_jieli_rc_protocol_adapter.py
  class CooingdvJieliRcProtocolAdapter (line 24) | class CooingdvJieliRcProtocolAdapter(BaseProtocolAdapter):
    method __init__ (line 49) | def __init__(
    method build_control_packet (line 90) | def build_control_packet(self, drone_model: CooingdvRcModel) -> bytes:
    method send_control_packet (line 97) | def send_control_packet(self, packet: bytes) -> None:
    method toggle_debug (line 111) | def toggle_debug(self) -> bool:
    method stop (line 116) | def stop(self) -> None:
    method start_heartbeat (line 124) | def start_heartbeat(self) -> None:
    method stop_heartbeat (line 137) | def stop_heartbeat(self) -> None:
    method _heartbeat_loop (line 144) | def _heartbeat_loop(self) -> None:
    method _send_control_mode (line 149) | def _send_control_mode(self, enabled: bool) -> None:
    method _send_ctp (line 152) | def _send_ctp(self, topic: str, params: dict[str, str]) -> None:
    method _build_flying_payload (line 159) | def _build_flying_payload(self, model: CooingdvRcModel) -> list[int]:
    method _build_flags (line 170) | def _build_flags(self, model: CooingdvRcModel) -> int:
    method _clear_one_shot_flags (line 186) | def _clear_one_shot_flags(self, model: CooingdvRcModel) -> None:
    method _clamp_axis (line 193) | def _clamp_axis(self, value: float) -> int:

FILE: backend/protocols/cooingdv_jieli_video_protocol.py
  class CooingdvJieliVideoProtocolAdapter (line 26) | class CooingdvJieliVideoProtocolAdapter(BaseVideoProtocolAdapter):
    method __init__ (line 39) | def __init__(
    method start (line 70) | def start(self) -> None:
    method stop (line 90) | def stop(self) -> None:
    method is_running (line 104) | def is_running(self) -> bool:
    method get_frame (line 107) | def get_frame(self, timeout: float = 1.0) -> Optional[VideoFrame]:
    method get_packets (line 113) | def get_packets(self) -> list[bytes]:
    method send_start_command (line 116) | def send_start_command(self) -> None:
    method create_receiver_socket (line 119) | def create_receiver_socket(self):
    method handle_payload (line 122) | def handle_payload(self, payload: bytes) -> Optional[VideoFrame]:
    method _send_open_stream (line 126) | def _send_open_stream(self) -> None:
    method _send_close_stream (line 137) | def _send_close_stream(self) -> None:
    method _send_ctp (line 140) | def _send_ctp(self, topic: str, params: dict[str, str]) -> None:
    method _start_sdp_server (line 150) | def _start_sdp_server(self) -> None:
    method _sdp_loop (line 158) | def _sdp_loop(self) -> None:
    method _rx_loop (line 193) | def _rx_loop(self) -> None:
    method _handle_rtp_packet (line 225) | def _handle_rtp_packet(self, packet: bytes) -> Optional[VideoFrame]:
    method _handle_rtp_jpeg (line 245) | def _handle_rtp_jpeg(self, timestamp: int, payload: bytes, marker: boo...
    method _handle_possible_raw_jpeg (line 267) | def _handle_possible_raw_jpeg(self, payload: bytes) -> Optional[VideoF...

FILE: backend/protocols/cooingdv_rc_protocol_adapter.py
  class CooingdvRcProtocolAdapter (line 30) | class CooingdvRcProtocolAdapter(BaseProtocolAdapter):
    method __init__ (line 80) | def __init__(
    method start_heartbeat (line 137) | def start_heartbeat(self) -> None:
    method stop_heartbeat (line 151) | def stop_heartbeat(self) -> None:
    method _heartbeat_loop (line 159) | def _heartbeat_loop(self) -> None:
    method start_receiver (line 170) | def start_receiver(self) -> None:
    method stop_receiver (line 184) | def stop_receiver(self) -> None:
    method _receiver_loop (line 192) | def _receiver_loop(self) -> None:
    method _process_received_packet (line 210) | def _process_received_packet(self, packet: bytes, addr: tuple[str, int...
    method stop (line 250) | def stop(self) -> None:
    method build_control_packet (line 266) | def build_control_packet(self, drone_model: CooingdvRcModel) -> bytes:
    method send_control_packet (line 277) | def send_control_packet(self, packet: bytes) -> None:
    method toggle_debug (line 305) | def toggle_debug(self) -> bool:
    method _active_variant (line 315) | def _active_variant(self) -> str:
    method _normalise_variant (line 323) | def _normalise_variant(self, value: Optional[str]) -> Optional[str]:
    method _detect_variant (line 338) | def _detect_variant(self, packet: bytes) -> Optional[str]:
    method _build_tc_control_packet (line 347) | def _build_tc_control_packet(self, model: CooingdvRcModel) -> bytes:
    method _build_gl_control_packet (line 360) | def _build_gl_control_packet(self, model: CooingdvRcModel) -> bytes:
    method _clamp_axis (line 383) | def _clamp_axis(self, value: float) -> int:
    method _build_tc_flags (line 388) | def _build_tc_flags(self, model: CooingdvRcModel) -> int:
    method _build_gl_flags (line 406) | def _build_gl_flags(self, model: CooingdvRcModel) -> tuple[int, int]:
    method _clear_one_shot_flags (line 430) | def _clear_one_shot_flags(self, model: CooingdvRcModel) -> None:
    method _decode_tc_flags (line 437) | def _decode_tc_flags(self, flags: int) -> list[str]:
    method _decode_gl_flags (line 453) | def _decode_gl_flags(self, flags1: int, flags2: int) -> list[str]:
    method _calculate_checksum (line 467) | def _calculate_checksum(self, data: bytes) -> int:

FILE: backend/protocols/cooingdv_video_protocol.py
  class CooingdvVideoProtocolAdapter (line 27) | class CooingdvVideoProtocolAdapter(BaseVideoProtocolAdapter):
    method __init__ (line 55) | def __init__(
    method _open_stream (line 95) | def _open_stream(self) -> bool:
    method _close_stream (line 124) | def _close_stream(self) -> None:
    method _reconnect (line 132) | def _reconnect(self) -> bool:
    method send_start_command (line 155) | def send_start_command(self) -> None:
    method create_receiver_socket (line 162) | def create_receiver_socket(self):
    method handle_payload (line 169) | def handle_payload(self, payload: bytes) -> Optional[VideoFrame]:
    method start (line 178) | def start(self) -> None:
    method _rx_loop (line 199) | def _rx_loop(self) -> None:
    method stop (line 258) | def stop(self) -> None:
    method is_running (line 277) | def is_running(self) -> bool:
    method get_frame (line 281) | def get_frame(self, timeout: float = 1.0) -> Optional[VideoFrame]:
    method get_packets (line 288) | def get_packets(self) -> List[bytes]:
    method start_keepalive (line 298) | def start_keepalive(self, interval: float = 1.0) -> None:
    method stop_keepalive (line 302) | def stop_keepalive(self) -> None:

FILE: backend/protocols/debug_rc_protocol_adapter.py
  class DebugRcProtocolAdapter (line 5) | class DebugRcProtocolAdapter:
    method __init__ (line 8) | def __init__(self):
    method send_control_data (line 11) | def send_control_data(self, data: bytes):

FILE: backend/protocols/debug_video_protocol.py
  class DebugVideoProtocolAdapter (line 15) | class DebugVideoProtocolAdapter(BaseVideoProtocolAdapter):
    method __init__ (line 20) | def __init__(self, camera_index: int = 0, debug: bool = False, max_que...
    method start (line 31) | def start(self):
    method stop (line 41) | def stop(self):
    method is_running (line 54) | def is_running(self) -> bool:
    method get_frame (line 57) | def get_frame(self, timeout: float = 1.0) -> Optional[VideoFrame]:
    method get_packets (line 63) | def get_packets(self) -> List[bytes]:
    method _capture_loop (line 67) | def _capture_loop(self):
    method create_receiver_socket (line 101) | def create_receiver_socket(self):
    method send_start_command (line 104) | def send_start_command(self):
    method handle_payload (line 107) | def handle_payload(self, payload: bytes) -> Optional[VideoFrame]:

FILE: backend/protocols/no_video_protocol.py
  class NoVideoProtocolAdapter (line 13) | class NoVideoProtocolAdapter(BaseVideoProtocolAdapter):
    method __init__ (line 22) | def __init__(
    method start (line 34) | def start(self) -> None:
    method stop (line 38) | def stop(self) -> None:
    method is_running (line 41) | def is_running(self) -> bool:
    method get_frame (line 44) | def get_frame(self, timeout: float = 1.0) -> Optional[VideoFrame]:
    method get_packets (line 49) | def get_packets(self) -> list[bytes]:
    method send_start_command (line 52) | def send_start_command(self) -> None:
    method create_receiver_socket (line 55) | def create_receiver_socket(self):
    method handle_payload (line 58) | def handle_payload(self, payload: bytes) -> Optional[VideoFrame]:

FILE: backend/protocols/s2x_rc_protocol_adapter.py
  class S2xRCProtocolAdapter (line 4) | class S2xRCProtocolAdapter(BaseProtocolAdapter):
    method __init__ (line 7) | def __init__(self, drone_ip, control_port=8080):
    method build_control_packet (line 22) | def build_control_packet(self, drone_model):
    method send_control_packet (line 79) | def send_control_packet(self, packet):
    method toggle_debug (line 107) | def toggle_debug(self):
    method _remap_to_full_range (line 112) | def _remap_to_full_range(self, value, model):
    method _scale_axis (line 121) | def _scale_axis(self, value, model, scale):

FILE: backend/protocols/s2x_video_protocol.py
  class S2xVideoProtocolAdapter (line 12) | class S2xVideoProtocolAdapter(BaseVideoProtocolAdapter):
    method __init__ (line 20) | def __init__(
    method send_start_command (line 43) | def send_start_command(self) -> None:
    method start_keepalive (line 49) | def start_keepalive(self, interval: float = 2.0) -> None:
    method stop_keepalive (line 61) | def stop_keepalive(self) -> None:
    method create_receiver_socket (line 69) | def create_receiver_socket(self) -> socket.socket:
    method get_receiver_socket (line 77) | def get_receiver_socket(self) -> socket.socket:
    method recv_from_socket (line 82) | def recv_from_socket(self, sock: socket.socket) -> Optional[bytes]:
    method handle_payload (line 89) | def handle_payload(self, payload: bytes) -> Optional[VideoFrame]:
    method stop (line 130) | def stop(self) -> None:
    method _keepalive_loop (line 143) | def _keepalive_loop(self, interval: float, stop_event: threading.Event...
    method start (line 149) | def start(self) -> None:
    method is_running (line 178) | def is_running(self) -> bool:
    method get_frame (line 181) | def get_frame(self, timeout: float = 1.0) -> Optional[VideoFrame]:
    method get_packets (line 187) | def get_packets(self) -> List[bytes]:
    method _discover_local_ip (line 193) | def _discover_local_ip(self) -> str:

FILE: backend/protocols/wifi_cam_rc_protocol_adapter.py
  class WifiCamRcProtocolAdapter (line 17) | class WifiCamRcProtocolAdapter(BaseProtocolAdapter):
    method __init__ (line 41) | def __init__(
    method build_control_packet (line 57) | def build_control_packet(self, drone_model: WifiCamRcModel) -> bytes:
    method send_control_packet (line 65) | def send_control_packet(self, packet: bytes) -> None:
    method set_camera_type (line 75) | def set_camera_type(self, camera_type: int) -> None:
    method stop (line 84) | def stop(self) -> None:
    method toggle_debug (line 90) | def toggle_debug(self) -> bool:
    method _build_short_packet (line 95) | def _build_short_packet(self, model: WifiCamRcModel) -> bytes:
    method _build_extended_packet (line 107) | def _build_extended_packet(self, model: WifiCamRcModel) -> bytes:
    method _build_short_flags (line 122) | def _build_short_flags(self, model: WifiCamRcModel) -> int:
    method _build_extended_flags (line 138) | def _build_extended_flags(self, model: WifiCamRcModel) -> tuple[int, i...
    method _clear_one_shot_flags (line 156) | def _clear_one_shot_flags(self, model: WifiCamRcModel) -> None:
    method _uses_extended_mode (line 163) | def _uses_extended_mode(self) -> bool:
    method _normalize_mode (line 170) | def _normalize_mode(self, command_mode: str) -> CommandMode:
    method _axis (line 177) | def _axis(self, value: float) -> int:
    method _right_data (line 180) | def _right_data(self, value: int) -> int:
    method _xor (line 186) | def _xor(self, values: bytes | bytearray) -> int:

FILE: backend/protocols/wifi_cam_video_protocol.py
  class WifiCamVideoProtocolAdapter (line 17) | class WifiCamVideoProtocolAdapter(BaseVideoProtocolAdapter):
    method __init__ (line 35) | def __init__(
    method set_rc_adapter (line 59) | def set_rc_adapter(self, rc_adapter) -> None:
    method start (line 64) | def start(self) -> None:
    method stop (line 78) | def stop(self) -> None:
    method is_running (line 92) | def is_running(self) -> bool:
    method get_frame (line 95) | def get_frame(self, timeout: float = 1.0) -> Optional[VideoFrame]:
    method get_packets (line 101) | def get_packets(self) -> list[bytes]:
    method send_start_command (line 107) | def send_start_command(self) -> None:
    method create_receiver_socket (line 110) | def create_receiver_socket(self) -> socket.socket:
    method handle_payload (line 119) | def handle_payload(self, payload: bytes) -> Optional[VideoFrame]:
    method switch_camera (line 155) | def switch_camera(self) -> None:
    method rotate (line 158) | def rotate(self) -> None:
    method _rx_loop (line 161) | def _rx_loop(self) -> None:
    method _send_command (line 188) | def _send_command(self, command: bytes) -> None:
    method _parse_camera_type (line 197) | def _parse_camera_type(self, payload: bytes) -> Optional[int]:
    method _set_camera_type (line 206) | def _set_camera_type(self, camera_type: int) -> None:
    method _finish_frame (line 214) | def _finish_frame(

FILE: backend/protocols/wifi_uav_rc_protocol_adapter.py
  class WifiUavRcProtocolAdapter (line 9) | class WifiUavRcProtocolAdapter(BaseProtocolAdapter):
    method __init__ (line 53) | def __init__(self,
    method set_socket (line 74) | def set_socket(self, sock: socket.socket) -> None:
    method stop (line 83) | def stop(self) -> None:
    method build_control_packet (line 94) | def build_control_packet(self, drone_model: WifiUavRcModel) -> bytes: ...
    method send_control_packet (line 174) | def send_control_packet(self, packet: bytes):  # type: ignore[override]
    method toggle_debug (line 217) | def toggle_debug(self) -> bool:                # type: ignore[override]
    method _resolve_target_ports (line 223) | def _resolve_target_ports(self, control_port: int) -> tuple[int, ...]:
    method _apply_speed_scale (line 228) | def _apply_speed_scale(self, value: float, speed_index: int) -> int:

FILE: backend/protocols/wifi_uav_video_protocol.py
  class WifiUavVideoProtocolAdapter (line 21) | class WifiUavVideoProtocolAdapter(BaseVideoProtocolAdapter):
    method __init__ (line 48) | def __init__(
    method start_keepalive (line 112) | def start_keepalive(self, interval: float = 1.0) -> None:  # type: ign...
    method stop_keepalive (line 115) | def stop_keepalive(self) -> None:  # type: ignore[override]
    method create_receiver_socket (line 121) | def create_receiver_socket(self) -> socket.socket:
    method send_start_command (line 124) | def send_start_command(self) -> None:
    method handle_payload (line 129) | def handle_payload(self, payload: bytes) -> Optional[VideoFrame]:
    method _warmup_loop (line 212) | def _warmup_loop(self) -> None:
    method _send_frame_request (line 223) | def _send_frame_request(self, frame_id: int) -> None:
    method _build_ack_slots (line 235) | def _build_ack_slots(self, seq: int) -> list[bytes]:
    method _parse_fragment_header (line 238) | def _parse_fragment_header(self, payload: bytes) -> Optional[tuple[int...
    method _resolve_target_ports (line 261) | def _resolve_target_ports(self, control_port: int) -> tuple[int, ...]:
    method _create_duplex_socket (line 271) | def _create_duplex_socket(self) -> socket.socket:
    method get_receiver_socket (line 279) | def get_receiver_socket(self) -> socket.socket:
    method set_rc_adapter (line 284) | def set_rc_adapter(self, rc_adapter) -> None:
    method start (line 297) | def start(self) -> None:
    method is_running (line 349) | def is_running(self) -> bool:
    method get_frame (line 360) | def get_frame(self, timeout: float = 1.0) -> Optional[VideoFrame]:
    method get_packets (line 370) | def get_packets(self) -> list[bytes]:
    method _watchdog_loop (line 379) | def _watchdog_loop(self) -> None:
    method stop (line 425) | def stop(self) -> None:

FILE: backend/receive_video.py
  function discover_local_ip (line 44) | def discover_local_ip(remote_ip=DRONE_IP):
  function send_start_command (line 57) | def send_start_command(drone_ip: str, my_ip: str):
  class ControlKeepAlive (line 67) | class ControlKeepAlive(threading.Thread):
    method __init__ (line 71) | def __init__(self, drone_ip, my_ip, interval=1.0):
    method run (line 78) | def run(self):
    method stop (line 83) | def stop(self):
  class VideoReceiver (line 89) | class VideoReceiver(threading.Thread):
    method __init__ (line 90) | def __init__(
    method stop (line 115) | def stop(self):
    method _reset_frame (line 118) | def _reset_frame(self, new_fid):
    method _finalise_frame (line 123) | def _finalise_frame(self, fid, fragments):
    method run (line 145) | def run(self):
  function display_frames (line 213) | def display_frames(frame_q: queue.Queue):
  function main (line 267) | def main():

FILE: backend/remote_control.py
  class DroneController (line 8) | class DroneController:
    method __init__ (line 9) | def __init__(self, drone_ip, control_port):
    method update_axes (line 49) | def update_axes(self, dt, throttle_dir, yaw_dir, pitch_dir, roll_dir):
    method remap_to_full_range (line 101) | def remap_to_full_range(self, value):
    method build_packet_hy (line 110) | def build_packet_hy(self):
    method send_loop (line 155) | def send_loop(self, interval=0.03):
    method stop_loop (line 191) | def stop_loop(self):
    method toggle_debug (line 194) | def toggle_debug(self):
  function ui_loop (line 200) | def ui_loop(stdscr, controller):
  function main (line 319) | def main():

FILE: backend/services/flight_controller.py
  class FlightController (line 8) | class FlightController:
    method __init__ (line 11) | def __init__(self, drone_model, protocol_adapter, update_rate=80.0):
    method start (line 30) | def start(self):
    method stop (line 36) | def stop(self):
    method set_control_direction (line 45) | def set_control_direction(self, control, direction):
    method set_axes (line 56) | def set_axes(self, throttle: float, yaw: float, pitch: float, roll: fl...
    method set_axes_from (line 63) | def set_axes_from(self, source: str, throttle: float, yaw: float, pitc...
    method _control_loop (line 94) | def _control_loop(self):

FILE: backend/services/video_receiver.py
  class VideoReceiverService (line 14) | class VideoReceiverService:
    method __init__ (line 20) | def __init__(
    method start (line 53) | def start(self) -> None:
    method stop (line 63) | def stop(self) -> None:
    method get_frame_queue (line 75) | def get_frame_queue(self) -> queue.Queue:
    method _receiver_loop (line 79) | def _receiver_loop(self) -> None:
    method _dump_frame (line 144) | def _dump_frame(self, frame: "VideoFrame | bytes | bytearray | memoryv...

FILE: backend/tests/test_cooingdv_jieli_ctp.py
  class CooingdvJieliCtpTests (line 8) | class CooingdvJieliCtpTests(unittest.TestCase):
    method test_builds_little_endian_ctp_packet (line 9) | def test_builds_little_endian_ctp_packet(self):
    method test_flying_control_payload_preserves_tc_bytes (line 21) | def test_flying_control_payload_preserves_tc_bytes(self):

FILE: backend/tests/test_s2x_protocol.py
  class S2xRcProtocolTests (line 7) | class S2xRcProtocolTests(unittest.TestCase):
    method _adapter (line 8) | def _adapter(self):
    method test_default_packet_matches_macrochip_hy_layout (line 18) | def test_default_packet_matches_macrochip_hy_layout(self):
    method test_swap_yaw_roll_changes_transmitted_axes (line 35) | def test_swap_yaw_roll_changes_transmitted_axes(self):
    method test_speed_index_scales_roll_and_pitch_only (line 49) | def test_speed_index_scales_roll_and_pitch_only(self):

FILE: backend/tests/test_s2x_video_protocol.py
  class S2xVideoProtocolTests (line 7) | class S2xVideoProtocolTests(unittest.TestCase):
    method _adapter (line 8) | def _adapter(self):
    method _packet (line 13) | def _packet(self, frame_id: int, total_chunks: int, chunk_id: int, bod...
    method test_emits_frame_when_all_declared_chunks_arrive (line 22) | def test_emits_frame_when_all_declared_chunks_arrive(self):
    method test_accepts_out_of_order_chunks (line 35) | def test_accepts_out_of_order_chunks(self):
    method test_rejects_mismatched_declared_length (line 46) | def test_rejects_mismatched_declared_length(self):

FILE: backend/tests/test_wifi_cam_protocol.py
  class WifiCamRcProtocolTests (line 8) | class WifiCamRcProtocolTests(unittest.TestCase):
    method _adapter (line 9) | def _adapter(self, mode="short"):
    method test_short_packet_matches_base_cmd_layout (line 15) | def test_short_packet_matches_base_cmd_layout(self):
    method test_short_packet_escapes_marker_checksum (line 30) | def test_short_packet_escapes_marker_checksum(self):
    method test_extended_packet_uses_camera_type_two_in_auto_mode (line 42) | def test_extended_packet_uses_camera_type_two_in_auto_mode(self):
  class FakeRcAdapter (line 64) | class FakeRcAdapter:
    method __init__ (line 65) | def __init__(self):
    method set_camera_type (line 68) | def set_camera_type(self, camera_type):
  class WifiCamVideoProtocolTests (line 72) | class WifiCamVideoProtocolTests(unittest.TestCase):
    method test_camera_type_probe_updates_rc_adapter (line 73) | def test_camera_type_probe_updates_rc_adapter(self):
    method test_single_chunk_jpeg_frame (line 84) | def test_single_chunk_jpeg_frame(self):
    method test_multi_chunk_jpeg_frame_uses_native_final_marker (line 97) | def test_multi_chunk_jpeg_frame_uses_native_final_marker(self):
    method test_rejects_final_chunk_without_jpeg_tail (line 111) | def test_rejects_final_chunk_without_jpeg_tail(self):

FILE: backend/utils/cooingdv_jieli_ctp.py
  function build_ctp_packet (line 11) | def build_ctp_packet(
  function parse_ctp_packet (line 39) | def parse_ctp_packet(packet: bytes) -> tuple[str, dict]:

FILE: backend/utils/dropping_queue.py
  class DroppingQueue (line 3) | class DroppingQueue(queue.Queue):
    method put (line 7) | def put(self, item, block=True, timeout=None):
    method put_nowait (line 35) | def put_nowait(self, item):

FILE: backend/utils/logging_config.py
  function _normalise_level (line 14) | def _normalise_level(raw: str | None) -> str:
  function bootstrap_runtime (line 23) | def bootstrap_runtime() -> None:
  function configure_logging (line 47) | def configure_logging(level: str | None = None) -> str:

FILE: backend/utils/wifi_uav_ack_state.py
  class WifiUavFrameSlot (line 18) | class WifiUavFrameSlot:
    method reset (line 29) | def reset(self, seq: int, fragment_total: int, frame_body_len: int, qu...
    method ingest (line 38) | def ingest(
    method is_complete (line 66) | def is_complete(self) -> bool:
    method ordered_payload (line 73) | def ordered_payload(self) -> bytes:
    method mark_delivered (line 76) | def mark_delivered(self) -> None:
    method mark_dropped (line 79) | def mark_dropped(self) -> None:
    method ack_status (line 82) | def ack_status(self) -> int:
    method ack_bitmap (line 91) | def ack_bitmap(self) -> bytes:
    method ack_slot (line 96) | def ack_slot(self) -> bytes:
  class WifiUavAckState (line 100) | class WifiUavAckState:
    method __init__ (line 110) | def __init__(self) -> None:
    method reset (line 116) | def reset(self) -> None:
    method ingest_fragment (line 129) | def ingest_fragment(
    method mark_delivered (line 156) | def mark_delivered(self, seq: int) -> None:
    method mark_dropped (line 163) | def mark_dropped(self, seq: int) -> None:
    method build_ack_slots (line 168) | def build_ack_slots(self, request_seq: int) -> list[bytes]:
    method _slot_for_seq (line 185) | def _slot_for_seq(self, seq: int) -> WifiUavFrameSlot:
    method _find_slot (line 188) | def _find_slot(self, seq: int) -> Optional[WifiUavFrameSlot]:

FILE: backend/utils/wifi_uav_jpeg.py
  function generate_dqt_segment (line 35) | def generate_dqt_segment(id: int, table: List[int], precision: int = 0) ...
  function generate_sof0_segment (line 74) | def generate_sof0_segment(width: int, height: int, num_components: int =...
  function generate_sos_segment (line 139) | def generate_sos_segment(
  function generate_jpeg_headers (line 183) | def generate_jpeg_headers(width: int, height: int, num_components: int =...

FILE: backend/utils/wifi_uav_packets.py
  function build_fragment_ack_bitmap (line 59) | def build_fragment_ack_bitmap(fragment_total: int, received_fragments: s...
  function build_ack_slot (line 73) | def build_ack_slot(seq: int, status: int, bitmap: bytes = b"") -> bytes:
  function build_native_ack_packet (line 84) | def build_native_ack_packet(

FILE: backend/utils/wifi_uav_variants.py
  class WifiUavCapabilities (line 21) | class WifiUavCapabilities:
  function wifi_uav_variant_from_drone_type (line 50) | def wifi_uav_variant_from_drone_type(drone_type: str) -> str:
  function resolve_wifi_uav_variant (line 60) | def resolve_wifi_uav_variant(drone_type: str) -> str:
  function get_wifi_uav_capabilities (line 80) | def get_wifi_uav_capabilities(variant: str) -> WifiUavCapabilities:
  function resolve_wifi_uav_capabilities (line 85) | def resolve_wifi_uav_capabilities(drone_type: str) -> WifiUavCapabilities:
  function map_wifi_uav_variant_from_ssid (line 90) | def map_wifi_uav_variant_from_ssid(ssid: str | None) -> str | None:
  function detect_active_wifi_ssid (line 103) | def detect_active_wifi_ssid() -> str | None:
  function _detect_ssid_windows (line 125) | def _detect_ssid_windows() -> str | None:
  function _detect_ssid_macos (line 147) | def _detect_ssid_macos() -> str | None:
  function _detect_ssid_linux (line 170) | def _detect_ssid_linux() -> str | None:

FILE: backend/video_client.py
  function main (line 13) | def main():

FILE: backend/views/base_video_view.py
  class BaseVideoView (line 3) | class BaseVideoView(ABC):
    method __init__ (line 6) | def __init__(self, frame_queue):
    method run (line 11) | def run(self):
    method stop (line 16) | def stop(self):

FILE: backend/views/cli_rc.py
  class CLIView (line 7) | class CLIView:
    method __init__ (line 10) | def __init__(self, flight_controller):
    method run (line 16) | def run(self):
    method _ui_loop (line 20) | def _ui_loop(self, stdscr):

FILE: backend/views/opencv_video_view.py
  class OpenCVVideoView (line 9) | class OpenCVVideoView(BaseVideoView):
    method __init__ (line 12) | def __init__(self, frame_queue, window_name="Drone Video"):
    method _wakeup_highgui (line 19) | def _wakeup_highgui(self):
    method run (line 29) | def run(self):
    method stop (line 89) | def stop(self):

FILE: backend/web_server.py
  class ConnectionManager (line 48) | class ConnectionManager:
    method __init__ (line 52) | def __init__(self):
    method connect (line 55) | async def connect(self, websocket: WebSocket):
    method disconnect (line 59) | def disconnect(self, websocket: WebSocket):
    method broadcast (line 63) | async def broadcast(self, message: str):
    method broadcast_bytes (line 72) | async def broadcast_bytes(self, message: bytes):
    method broadcast_json (line 81) | async def broadcast_json(self, obj: Any):
  function _control_capabilities_for_drone (line 101) | def _control_capabilities_for_drone(drone_type: str) -> dict[str, bool]:
  class FrameHub (line 148) | class FrameHub:
    method __init__ (line 155) | def __init__(self, per_client_queue_size: int = 2):
    method register (line 160) | async def register(self) -> asyncio.Queue:
    method unregister (line 166) | async def unregister(self, q: asyncio.Queue) -> None:
    method publish (line 170) | async def publish(self, frame: Optional[bytes]) -> None:
  function lifespan (line 193) | async def lifespan(app: FastAPI):
  function get_capabilities (line 431) | async def get_capabilities():
  function get_plugins (line 439) | async def get_plugins():
  function start_plugin (line 450) | async def start_plugin(name: str):
  function stop_plugin (line 475) | async def stop_plugin(name: str):
  function websocket_overlay_endpoint (line 494) | async def websocket_overlay_endpoint(websocket: WebSocket):
  function ws_endpoint (line 505) | async def ws_endpoint(websocket: WebSocket) -> None:
  function _frame_pump_worker (line 579) | def _frame_pump_worker(
  function mjpeg_stream (line 641) | async def mjpeg_stream():
  class OverlayBroadcaster (line 665) | class OverlayBroadcaster:
    method __init__ (line 666) | def __init__(self, q: queue.Queue, loop: asyncio.AbstractEventLoop):
    method start (line 672) | def start(self):
    method stop (line 676) | def stop(self):
    method _run (line 681) | def _run(self):

FILE: experimental/test_e88pro.py
  class VideoStreamThread (line 39) | class VideoStreamThread(QThread):
    method __init__ (line 47) | def __init__(self, rtsp_url):
    method run (line 55) | def run(self):
    method stop (line 114) | def stop(self):
    method reinitialize_stream (line 120) | def reinitialize_stream(self):
  class UDPListenerThread (line 130) | class UDPListenerThread(QThread):
    method __init__ (line 138) | def __init__(self, port, buffer_size):
    method run (line 146) | def run(self):
    method stop (line 180) | def stop(self):
  class RTSPViewerApp (line 192) | class RTSPViewerApp(QMainWindow):
    method __init__ (line 198) | def __init__(self):
    method send (line 269) | def send(self):
    method xor (line 298) | def xor(self,bs):
    method keyPressEvent (line 305) | def keyPressEvent(self, event):
    method update_image (line 366) | def update_image(self, pixmap):
    method update_udp_response (line 372) | def update_udp_response(self, data, addr):
    method show_error_message (line 377) | def show_error_message(self, message):
    method send_udp_command (line 390) | def send_udp_command(self, command):
    method on_up_button_clicked (line 399) | def on_up_button_clicked(self):
    method on_down_button_clicked (line 406) | def on_down_button_clicked(self):
    method closeEvent (line 413) | def closeEvent(self, event):

FILE: frontend/src/App.tsx
  function App (line 8) | function App() {

FILE: frontend/src/components/AxisIndicator.tsx
  type Props (line 1) | interface Props {
  function AxisIndicator (line 8) | function AxisIndicator({ x, y, size = 120, label }: Props) {

FILE: frontend/src/components/CommandButtons.tsx
  type CommandButtonsProps (line 3) | interface CommandButtonsProps {
  function CommandButtons (line 17) | function CommandButtons({

FILE: frontend/src/components/ControlSchemeToggle.tsx
  type Props (line 4) | interface Props {

FILE: frontend/src/components/ControlsOverlay.tsx
  type ControlsOverlayProps (line 6) | interface ControlsOverlayProps {
  function ControlsOverlay (line 17) | function ControlsOverlay({

FILE: frontend/src/components/DrawingOverlay.tsx
  function DrawingOverlay (line 4) | function DrawingOverlay() {

FILE: frontend/src/components/PluginControls.tsx
  function PluginControls (line 3) | function PluginControls() {

FILE: frontend/src/components/SpeedControl.tsx
  type SpeedControlProps (line 3) | interface SpeedControlProps {
  constant TIERS (line 9) | const TIERS: { value: SpeedTier; label: string; help: string }[] = [
  function SpeedControl (line 15) | function SpeedControl({ enabled, value, onChange }: SpeedControlProps) {

FILE: frontend/src/components/StaticDrawingOverlay.tsx
  function StaticDrawingOverlay (line 8) | function StaticDrawingOverlay() {

FILE: frontend/src/components/VideoFeed.tsx
  function VideoFeed (line 1) | function VideoFeed({ src }: { src: string }) {

FILE: frontend/src/hooks/useControls.ts
  type ControlMode (line 5) | type ControlMode = "inc" | "abs" | "mouse";
  type Axes (line 7) | interface Axes {
  type CommandCapabilities (line 14) | interface CommandCapabilities {
  type SpeedTier (line 23) | type SpeedTier = 0 | 1 | 2;
  function useControls (line 26) | function useControls() {

FILE: frontend/src/hooks/useOverlays.ts
  constant OVERLAY_WS_URL (line 3) | const OVERLAY_WS_URL = 'ws://localhost:8000/ws/overlays';
  type OverlayObject (line 5) | interface OverlayObject {
  function useOverlays (line 11) | function useOverlays() {

FILE: frontend/src/hooks/usePlugins.ts
  constant API_BASE_URL (line 4) | const API_BASE_URL = 'http://localhost:8000';
  type PluginState (line 6) | interface PluginState {
  function usePlugins (line 11) | function usePlugins() {

FILE: frontend/src/hooks/useVideoSizing.ts
  constant ZERO_RECT (line 3) | const ZERO_RECT = { x: 0, y: 0, width: 0, height: 0, top: 0, left: 0, ri...
  function useVideoSizing (line 5) | function useVideoSizing() {

FILE: frontend/src/pages/TestPage.tsx
  function TestPage (line 4) | function TestPage() {