content: from __future__ import annotations
  
  import asyncio
  import collections
  import contextlib
  import logging
  import random
  import struct
  import sys
  import traceback
  import uuid
  from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Iterable, Mapping
  from types import TracebackType
  from typing import Any, Literal, cast, overload
  
  from ..exceptions import (
      ConcurrencyError,
      ConnectionClosed,
      ConnectionClosedOK,
      ProtocolError,
  )
  from ..frames import DATA_OPCODES, CloseCode, Frame, Opcode
  from ..http11 import Request, Response
  from ..protocol import CLOSED, OPEN, Event, Protocol, State
  from ..typing import BytesLike, Data, DataLike, LoggerLike, Subprotocol
  from .compatibility import (
      TimeoutError,
      aiter,
      anext,
      asyncio_timeout,
      asyncio_timeout_at,
  )
  from .messages import Assembler
  
  
  __all__ = ["Connection"]
  
  
  class Connection(asyncio.Protocol):
      """
      :mod:`asyncio` implementation of a WebSocket connection.
  
      :class:`Connection` provides APIs shared between WebSocket servers and
      clients.
  
      You shouldn't use it directly. Instead, use
      :class:`~websockets.asyncio.client.ClientConnection` or
      :class:`~websockets.asyncio.server.ServerConnection`.
  
      """
  
      def __init__(
          self,
          protocol: Protocol,
          *,
          ping_interval: float | None = 20,
          ping_timeout: float | None = 20,
          close_timeout: float | None = 10,
          max_queue: int | None | tuple[int | None, int | None] = 16,
          write_limit: int | tuple[int, int | None] = 2**15,
      ) -> None:
          self.protocol = protocol
          self.ping_interval = ping_interval
          self.ping_timeout = ping_timeout
          self.close_timeout = close_timeout
          if isinstance(max_queue, int) or max_queue is None:
              self.max_queue_high, self.max_queue_low = max_queue, None
          else:
              self.max_queue_high, self.max_queue_low = max_queue
          if isinstance(write_limit, int):
              self.write_limit_high, self.write_limit_low = write_limit, None
          else:
              self.write_limit_high, self.write_limit_low = write_limit
  
          # Inject reference to this instance in the protocol's logger.
          self.protocol.logger = logging.LoggerAdapter(
              self.protocol.logger,
              {"websocket": self},
          )
  
          # Copy attributes from the protocol for convenience.
          self.id: uuid.UUID = self.protocol.id
          """Unique identifier of the connection. Useful in logs."""
          self.logger: LoggerLike = self.protocol.logger
          """Logger for this connection."""
          self.debug = self.protocol.debug
  
          # HTTP handshake request and response.
          self.request: Request | None = None
          """Opening handshake request."""
          self.response: Response | None = None
          """Opening handshake response."""
  
          # Event loop running this connection.
          self.loop = asyncio.get_running_loop()
  
          # Assembler turning frames into messages and serializing reads.
          self.recv_messages: Assembler  # initialized in connection_made
  
          # Deadline for the closing handshake.
          self.close_deadline: float | None = None
  
          # Whether we are busy sending a fragmented message.
          self.send_in_progress: asyncio.Future[None] | None = None
  
          # Mapping of ping IDs to pong waiters, in chronological order.
          self.pending_pings: dict[bytes, tuple[asyncio.Future[float], float]] = {}
  
          self.latency: float = 0.0
          """
          Latency of the connection, in seconds.
  
          Latency is defined as the round-trip time of the connection. It is
          measured by sending a Ping frame and waiting for a matching Pong frame.
          Before the first measurement, :attr:`latency` is ``0.0``.
  
          By default, websockets enables a :ref:`keepalive <keepalive>` mechanism
          that sends Ping frames automatically at regular intervals. You can also
          send Ping frames and measure latency with :meth:`ping`.
          """
  
          # Task that sends keepalive pings. None when ping_interval is None.
          self.keepalive_task: asyncio.Task[None] | None = None
  
          # Exception raised while reading from the connection, to be chained to
          # ConnectionClosed in order to show why the TCP connection dropped.
          self.recv_exc: BaseException | None = None
  
          # Completed when the TCP connection is closed and the WebSocket
          # connection state becomes CLOSED.
          self.connection_lost_waiter: asyncio.Future[None] = self.loop.create_future()
  
          # Adapted from asyncio.FlowControlMixin.
          self.paused: bool = False
          self.drain_waiters: collections.deque[asyncio.Future[None]] = (
              collections.deque()
          )
  
      # Public attributes
  
      @property
      def local_address(self) -> Any:
          """
          Local address of the connection.
  
          For IPv4 connections, this is a ``(host, port)`` tuple.
  
          The format of the address depends on the address family.
          See :meth:`~socket.socket.getsockname`.
  
          """
          return self.transport.get_extra_info("sockname")
  
      @property
      def remote_address(self) -> Any:
          """
          Remote address of the connection.
  
          For IPv4 connections, this is a ``(host, port)`` tuple.
  
          The format of the address depends on the address family.
          See :meth:`~socket.socket.getpeername`.
  
          """
          return self.transport.get_extra_info("peername")
  
      @property
      def state(self) -> State:
          """
          State of the WebSocket connection, defined in :rfc:`6455`.
  
          This attribute is provided for completeness. Typical applications
          shouldn't check its value. Instead, they should call :meth:`~recv` or
          :meth:`send` and handle :exc:`~websockets.exceptions.ConnectionClosed`
          exceptions.
  
          """
          return self.protocol.state
  
      @property
      def subprotocol(self) -> Subprotocol | None:
          """
          Subprotocol negotiated during the opening handshake.
  
          :obj:`None` if no subprotocol was negotiated.
  
          """
          return self.protocol.subprotocol
  
      @property
      def close_code(self) -> int | None:
          """
          State of the WebSocket connection, defined in :rfc:`6455`.
  
          This attribute is provided for completeness. Typical applications
          shouldn't check its value. Instead, they should inspect attributes
          of :exc:`~websockets.exceptions.ConnectionClosed` exceptions.
  
          """
          return self.protocol.close_code
  
      @property
      def close_reason(self) -> str | None:
          """
          State of the WebSocket connection, defined in :rfc:`6455`.
  
          This attribute is provided for completeness. Typical applications
          shouldn't check its value. Instead, they should inspect attributes
          of :exc:`~websockets.exceptions.ConnectionClosed` exceptions.
  
          """
          return self.protocol.close_reason
  
      # Public methods
  
      async def __aenter__(self) -> Connection:
          return self
  
      async def __aexit__(
          self,
          exc_type: type[BaseException] | None,
          exc_value: BaseException | None,
          traceback: TracebackType | None,
      ) -> None:
          if exc_type is None:
              await self.close()
          else:
              await self.close(CloseCode.INTERNAL_ERROR)
  
      async def __aiter__(self) -> AsyncIterator[Data]:
          """
          Iterate on incoming messages.
  
          The iterator calls :meth:`recv` and yields messages asynchronously in an
          infinite loop.
  
          It exits when the connection is closed normally. It raises a
          :exc:`~websockets.exceptions.ConnectionClosedError` exception after a
          protocol error or a network failure.
  
          """
          try:
              while True:
                  yield await self.recv()
          except ConnectionClosedOK:
              return
  
      @overload
      async def recv(self, decode: Literal[True]) -> str: ...
  
      @overload
      async def recv(self, decode: Literal[False]) -> bytes: ...
  
      @overload
      async def recv(self, decode: bool | None = None) -> Data: ...
  
      async def recv(self, decode: bool | None = None) -> Data:
          """
          Receive the next message.
  
          When the connection is closed, :meth:`recv` raises
          :exc:`~websockets.exceptions.ConnectionClosed`. Specifically, it raises
          :exc:`~websockets.exceptions.ConnectionClosedOK` after a normal closure
          and :exc:`~websockets.exceptions.ConnectionClosedError` after a protocol
          error or a network failure. This is how you detect the end of the
          message stream.
  
          Canceling :meth:`recv` is safe. There's no risk of losing data. The next
          invocation of :meth:`recv` will return the next message.
  
          This makes it possible to enforce a timeout by wrapping :meth:`recv` in
          :func:`~asyncio.timeout` or :func:`~asyncio.wait_for`.
  
          When the message is fragmented, :meth:`recv` waits until all fragments
          are received, reassembles them, and returns the whole message.
  
          Args:
              decode: Set this flag to override the default behavior of returning
                  :class:`str` or :class:`bytes`. See below for details.
  
          Returns:
              A string (:class:`str`) for a Text_ frame or a bytestring
              (:class:`bytes`) for a Binary_ frame.
  
              .. _Text: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
              .. _Binary: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
  
              You may override this behavior with the ``decode`` argument:
  
              * Set ``decode=False`` to disable UTF-8 decoding of Text_ frames and
                return a bytestring (:class:`bytes`). This improves performance
                when decoding isn't needed, for example if the message contains
                JSON and you're using a JSON library that expects a bytestring.
              * Set ``decode=True`` to force UTF-8 decoding of Binary_ frames and
                return strings (:class:`str`). This may be useful for servers that
                send binary frames instead of text frames.
  
          Raises:
              ConnectionClosed: When the connection is closed.
              ConcurrencyError: If two coroutines call :meth:`recv` or
                  :meth:`recv_streaming` concurrently.
  
          """
          try:
              return await self.recv_messages.get(decode)
          except EOFError:
              pass
              # fallthrough
          except ConcurrencyError:
              raise ConcurrencyError(
                  "cannot call recv while another coroutine "
                  "is already running recv or recv_streaming"
              ) from None
          except UnicodeDecodeError as exc:
              async with self.send_context():
                  self.protocol.fail(
                      CloseCode.INVALID_DATA,
                      f"{exc.reason} at position {exc.start}",
                  )
              # fallthrough
  
          # Wait for the protocol state to be CLOSED before accessing close_exc.
          await asyncio.shield(self.connection_lost_waiter)
          raise self.protocol.close_exc from self.recv_exc
  
      @overload
      def recv_streaming(self, decode: Literal[True]) -> AsyncIterator[str]: ...
  
      @overload
      def recv_streaming(self, decode: Literal[False]) -> AsyncIterator[bytes]: ...
  
      @overload
      def recv_streaming(self, decode: bool | None = None) -> AsyncIterator[Data]: ...
  
      async def recv_streaming(self, decode: bool | None = None) -> AsyncIterator[Data]:
          """
          Receive the next message frame by frame.
  
          This method is designed for receiving fragmented messages. It returns an
          asynchronous iterator that yields each fragment as it is received. This
          iterator must be fully consumed. Else, future calls to :meth:`recv` or
          :meth:`recv_streaming` will raise
          :exc:`~websockets.exceptions.ConcurrencyError`, making the connection
          unusable.
  
          :meth:`recv_streaming` raises the same exceptions as :meth:`recv`.
  
          Canceling :meth:`recv_streaming` before receiving the first frame is
          safe. Canceling it after receiving one or more frames leaves the
          iterator in a partially consumed state, making the connection unusable.
          Instead, you should close the connection with :meth:`close`.
  
          Args:
              decode: Set this flag to override the default behavior of returning
                  :class:`str` or :class:`bytes`. See below for details.
  
          Returns:
              An iterator of strings (:class:`str`) for a Text_ frame or
              bytestrings (:class:`bytes`) for a Binary_ frame.
  
              .. _Text: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
              .. _Binary: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
  
              You may override this behavior with the ``decode`` argument:
  
              * Set ``decode=False`` to disable UTF-8 decoding of Text_ frames and
                yield bytestrings (:class:`bytes`). This improves performance
                when decoding isn't needed.
              * Set ``decode=True`` to force UTF-8 decoding of Binary_ frames and
                yield strings (:class:`str`). This may be useful for servers that
                send binary frames instead of text frames.
  
          Raises:
              ConnectionClosed: When the connection is closed.
              ConcurrencyError: If two coroutines call :meth:`recv` or
                  :meth:`recv_streaming` concurrently.
  
          """
          try:
              async for frame in self.recv_messages.get_iter(decode):
                  yield frame
              return
          except EOFError:
              pass
              # fallthrough
          except ConcurrencyError:
              raise ConcurrencyError(
                  "cannot call recv_streaming while another coroutine "
                  "is already running recv or recv_streaming"
              ) from None
          except UnicodeDecodeError as exc:
              async with self.send_context():
                  self.protocol.fail(
                      CloseCode.INVALID_DATA,
                      f"{exc.reason} at position {exc.start}",
                  )
              # fallthrough
  
          # Wait for the protocol state to be CLOSED before accessing close_exc.
          await asyncio.shield(self.connection_lost_waiter)
          raise self.protocol.close_exc from self.recv_exc
  
      async def send(
          self,
          message: DataLike | Iterable[DataLike] | AsyncIterable[DataLike],
          text: bool | None = None,
      ) -> None:
          """
          Send a message.
  
          A string (:class:`str`) is sent as a Text_ frame. A bytestring or
          bytes-like object (:class:`bytes`, :class:`bytearray`, or
          :class:`memoryview`) is sent as a Binary_ frame.
  
          .. _Text: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
          .. _Binary: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
  
          You may override this behavior with the ``text`` argument:
  
          * Set ``text=True`` to send an UTF-8 bytestring or bytes-like object
            (:class:`bytes`, :class:`bytearray`, or :class:`memoryview`) in a
            Text_ frame. This improves performance when the message is already
            UTF-8 encoded, for example if the message contains JSON and you're
            using a JSON library that produces a bytestring.
          * Set ``text=False`` to send a string (:class:`str`) in a Binary_
            frame. This may be useful for servers that expect binary frames
            instead of text frames.
  
          :meth:`send` also accepts an iterable or asynchronous iterable of
          strings, bytestrings, or bytes-like objects to enable fragmentation_.
          Each item is treated as a message fragment and sent in its own frame.
          All items must be of the same type, or else :meth:`send` will raise a
          :exc:`TypeError` and the connection will be closed.
  
          .. _fragmentation: https://datatracker.ietf.org/doc/html/rfc6455#section-5.4
  
          :meth:`send` rejects dict-like objects because this is often an error.
          (If you really want to send the keys of a dict-like object as fragments,
          call its :meth:`~dict.keys` method and pass the result to :meth:`send`.)
  
          Canceling :meth:`send` is discouraged. Instead, you should close the
          connection with :meth:`close`. Indeed, there are only two situations
          where :meth:`send` may yield control to the event loop and then get
          canceled; in both cases, :meth:`close` has the same effect and the
          effect is more obvious:
  
          1. The write buffer is full. If you don't want to wait until enough
             data is sent, your only alternative is to close the connection.
             :meth:`close` will likely time out then abort the TCP connection.
          2. ``message`` is an asynchronous iterator that yields control.
             Stopping in the middle of a fragmented message will cause a
             protocol error and the connection will be closed.
  
          When the connection is closed, :meth:`send` raises
          :exc:`~websockets.exceptions.ConnectionClosed`. Specifically, it
          raises :exc:`~websockets.exceptions.ConnectionClosedOK` after a normal
          connection closure and
          :exc:`~websockets.exceptions.ConnectionClosedError` after a protocol
          error or a network failure.
  
          Args:
              message: Message to send.
  
          Raises:
              ConnectionClosed: When the connection is closed.
              TypeError: If ``message`` doesn't have a supported type.
  
          """
          # While sending a fragmented message, prevent sending other messages
          # until all fragments are sent.
          while self.send_in_progress is not None:
              await asyncio.shield(self.send_in_progress)
  
          # Unfragmented message -- this case must be handled first because
          # strings and bytes-like objects are iterable.
  
          if isinstance(message, str):
              async with self.send_context():
                  if text is False:
                      self.protocol.send_binary(message.encode())
                  else:
                      self.protocol.send_text(message.encode())
  
          elif isinstance(message, BytesLike):
              async with self.send_context():
                  if text is True:
                      self.protocol.send_text(message)
                  else:
                      self.protocol.send_binary(message)
  
          # Catch a common mistake -- passing a dict to send().
  
          elif isinstance(message, Mapping):
              raise TypeError("data is a dict-like object")
  
          # Fragmented message -- regular iterator.
  
          elif isinstance(message, Iterable):
              chunks = iter(message)
              try:
                  chunk = next(chunks)
              except StopIteration:
                  return
  
              assert self.send_in_progress is None
              self.send_in_progress = self.loop.create_future()
              try:
                  # First fragment.
                  if isinstance(chunk, str):
                      async with self.send_context():
                          if text is False:
                              self.protocol.send_binary(chunk.encode(), fin=False)
                          else:
                              self.protocol.send_text(chunk.encode(), fin=False)
                      encode = True
                  elif isinstance(chunk, BytesLike):
                      async with self.send_context():
                          if text is True:
                              self.protocol.send_text(chunk, fin=False)
                          else:
                              self.protocol.send_binary(chunk, fin=False)
                      encode = False
                  else:
                      raise TypeError("iterable must contain bytes or str")
  
                  # Other fragments
                  for chunk in chunks:
                      if isinstance(chunk, str) and encode:
                          async with self.send_context():
                              self.protocol.send_continuation(chunk.encode(), fin=False)
                      elif isinstance(chunk, BytesLike) and not encode:
                          async with self.send_context():
                              self.protocol.send_continuation(chunk, fin=False)
                      else:
                          raise TypeError("iterable must contain uniform types")
  
                  # Final fragment.
                  async with self.send_context():
                      self.protocol.send_continuation(b"", fin=True)
  
              except Exception:
                  # We're half-way through a fragmented message and we can't
                  # complete it. This makes the connection unusable.
                  async with self.send_context():
                      self.protocol.fail(
                          CloseCode.INTERNAL_ERROR,
                          "error in fragmented message",
                      )
                  raise
  
              finally:
                  self.send_in_progress.set_result(None)
                  self.send_in_progress = None
  
          # Fragmented message -- async iterator.
  
          elif isinstance(message, AsyncIterable):
              achunks = aiter(message)
              try:
                  chunk = await anext(achunks)
              except StopAsyncIteration:
                  return
  
              assert self.send_in_progress is None
              self.send_in_progress = self.loop.create_future()
              try:
                  # First fragment.
                  if isinstance(chunk, str):
                      if text is False:
                          async with self.send_context():
                              self.protocol.send_binary(chunk.encode(), fin=False)
                      else:
                          async with self.send_context():
                              self.protocol.send_text(chunk.encode(), fin=False)
                      encode = True
                  elif isinstance(chunk, BytesLike):
                      if text is True:
                          async with self.send_context():
                              self.protocol.send_text(chunk, fin=False)
                      else:
                          async with self.send_context():
                              self.protocol.send_binary(chunk, fin=False)
                      encode = False
                  else:
                      raise TypeError("async iterable must contain bytes or str")
  
                  # Other fragments
                  async for chunk in achunks:
                      if isinstance(chunk, str) and encode:
                          async with self.send_context():
                              self.protocol.send_continuation(chunk.encode(), fin=False)
                      elif isinstance(chunk, BytesLike) and not encode:
                          async with self.send_context():
                              self.protocol.send_continuation(chunk, fin=False)
                      else:
                          raise TypeError("async iterable must contain uniform types")
  
                  # Final fragment.
                  async with self.send_context():
                      self.protocol.send_continuation(b"", fin=True)
  
              except Exception:
                  # We're half-way through a fragmented message and we can't
                  # complete it. This makes the connection unusable.
                  async with self.send_context():
                      self.protocol.fail(
                          CloseCode.INTERNAL_ERROR,
                          "error in fragmented message",
                      )
                  raise
  
              finally:
                  self.send_in_progress.set_result(None)
                  self.send_in_progress = None
  
          else:
              raise TypeError("data must be str, bytes, iterable, or async iterable")
  
      async def close(
          self,
          code: CloseCode | int = CloseCode.NORMAL_CLOSURE,
          reason: str = "",
      ) -> None:
          """
          Perform the closing handshake.
  
          :meth:`close` waits for the other end to complete the handshake and
          for the TCP connection to terminate.
  
          :meth:`close` is idempotent: it doesn't do anything once the
          connection is closed.
  
          Args:
              code: WebSocket close code.
              reason: WebSocket close reason.
  
          """
          try:
              # The context manager takes care of waiting for the TCP connection
              # to terminate after calling a method that sends a close frame.
              async with self.send_context():
                  if self.send_in_progress is not None:
                      self.protocol.fail(
                          CloseCode.INTERNAL_ERROR,
                          "close during fragmented message",
                      )
                  else:
                      self.protocol.send_close(code, reason)
          except ConnectionClosed:
              # Ignore ConnectionClosed exceptions raised from send_context().
              # They mean that the connection is closed, which was the goal.
              pass
  
      async def wait_closed(self) -> None:
          """
          Wait until the connection is closed.
  
          :meth:`wait_closed` waits for the closing handshake to complete and for
          the TCP connection to terminate.
  
          """
          await asyncio.shield(self.connection_lost_waiter)
  
      async def ping(self, data: DataLike | None = None) -> Awaitable[float]:
          """
          Send a Ping_.
  
          .. _Ping: https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2
  
          A ping may serve as a keepalive or as a check that the remote endpoint
          received all messages up to this point
  
          Args:
              data: Payload of the ping. A :class:`str` will be encoded to UTF-8.
                  If ``data`` is :obj:`None`, the payload is four random bytes.
  
          Returns:
              A future that will be completed when the corresponding pong is
              received. You can ignore it if you don't intend to wait. The result
              of the future is the latency of the connection in seconds.
  
              ::
  
                  pong_received = await ws.ping()
                  # only if you want to wait for the corresponding pong
                  latency = await pong_received
  
          Raises:
              ConnectionClosed: When the connection is closed.
              ConcurrencyError: If another ping was sent with the same data and
                  the corresponding pong wasn't received yet.
  
          """
          if isinstance(data, BytesLike):
              data = bytes(data)
          elif isinstance(data, str):
              data = data.encode()
          elif data is not None:
              raise TypeError("data must be str or bytes-like")
  
          async with self.send_context():
              # Protect against duplicates if a payload is explicitly set.
              if data in self.pending_pings:
                  raise ConcurrencyError("already waiting for a pong with the same data")
  
              # Generate a unique random payload otherwise.
              while data is None or data in self.pending_pings:
                  data = struct.pack("!I", random.getrandbits(32))
  
              pong_received = self.loop.create_future()
              ping_timestamp = self.loop.time()
              # The event loop's default clock is time.monotonic(). Its resolution
              # is a bit low on Windows (~16ms). This is improved in Python 3.13.
              self.pending_pings[data] = (pong_received, ping_timestamp)
              self.protocol.send_ping(data)
              return pong_received
  
      async def pong(self, data: DataLike = b"") -> None:
          """
          Send a Pong_.
  
          .. _Pong: https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3
  
          An unsolicited pong may serve as a unidirectional heartbeat.
  
          Args:
              data: Payload of the pong. A :class:`str` will be encoded to UTF-8.
  
          Raises:
              ConnectionClosed: When the connection is closed.
  
          """
          if isinstance(data, BytesLike):
              data = bytes(data)
          elif isinstance(data, str):
              data = data.encode()
          else:
              raise TypeError("data must be str or bytes-like")
  
          async with self.send_context():
              self.protocol.send_pong(data)
  
      # Private methods
  
      def process_event(self, event: Event) -> None:
          """
          Process one incoming event.
  
          This method is overridden in subclasses to handle the handshake.
  
          """
          assert isinstance(event, Frame)
          if event.opcode in DATA_OPCODES:
              self.recv_messages.put(event)
  
          if event.opcode is Opcode.PONG:
              self.acknowledge_pings(bytes(event.data))
  
      def acknowledge_pings(self, data: bytes) -> None:
          """
          Acknowledge pings when receiving a pong.
  
          """
          # Ignore unsolicited pong.
          if data not in self.pending_pings:
              return
  
          pong_timestamp = self.loop.time()
  
          # Sending a pong for only the most recent ping is legal.
          # Acknowledge all previous pings too in that case.
          ping_id = None
          ping_ids = []
          for ping_id, (pong_received, ping_timestamp) in self.pending_pings.items():
              ping_ids.append(ping_id)
              latency = pong_timestamp - ping_timestamp
              if not pong_received.done():
                  pong_received.set_result(latency)
              if ping_id == data:
                  self.latency = latency
                  break
          else:
              raise AssertionError("solicited pong not found in pings")
  
          # Remove acknowledged pings from self.pending_pings.
          for ping_id in ping_ids:
              del self.pending_pings[ping_id]
  
      def terminate_pending_pings(self) -> None:
          """
          Raise ConnectionClosed in pending pings when the connection is closed.
  
          """
          assert self.protocol.state is CLOSED
          exc = self.protocol.close_exc
  
          for pong_received, _ping_timestamp in self.pending_pings.values():
              if not pong_received.done():
                  pong_received.set_exception(exc)
              # If the exception is never retrieved, it will be logged when ping
              # is garbage-collected. This is confusing for users.
              # Given that ping is done (with an exception), canceling it does
              # nothing, but it prevents logging the exception.
              pong_received.cancel()
  
          self.pending_pings.clear()
  
      async def keepalive(self) -> None:
          """
          Send a Ping frame and wait for a Pong frame at regular intervals.
  
          """
          assert self.ping_interval is not None
          latency = 0.0
          try:
              while True:
                  # If self.ping_timeout > latency > self.ping_interval,
                  # pings will be sent immediately after receiving pongs.
                  # The period will be longer than self.ping_interval.
                  await asyncio.sleep(self.ping_interval - latency)
  
                  # This cannot raise ConnectionClosed when the connection is
                  # closing because ping(), via send_context(), waits for the
                  # connection to be closed before raising ConnectionClosed.
                  # However, connection_lost() cancels keepalive_task before
                  # it gets a chance to resume excuting.
                  pong_received = await self.ping()
                  if self.debug:
                      self.logger.debug("% sent keepalive ping")
  
                  if self.ping_timeout is not None:
                      try:
                          async with asyncio_timeout(self.ping_timeout):
                              # connection_lost cancels keepalive immediately
                              # after setting a ConnectionClosed exception on
                              # pong_received. A CancelledError is raised here,
                              # not a ConnectionClosed exception.
                              latency = await pong_received
                              if self.debug:
                                  self.logger.debug("% received keepalive pong")
                      except asyncio.TimeoutError:
                          if self.debug:
                              self.logger.debug("- timed out waiting for keepalive pong")
                          async with self.send_context():
                              self.protocol.fail(
                                  CloseCode.INTERNAL_ERROR,
                                  "keepalive ping timeout",
                              )
                          raise AssertionError(
  