docs: def read(self, buffer_size, window_size, x, y, p, address, length_bytes):
          """Read a bytestring from an address in memory.
  
          ..note::
              This method is included here to maintain API compatibility with an
              `alternative implementation of SCP
              <https://github.com/project-rig/rig-scp>`_.
  
          Parameters
          ----------
          buffer_size : int
              Number of bytes held in an SCP buffer by SARK, determines how many
              bytes will be expected in a socket and how many bytes of data will
              be read back in each packet.
          window_size : int
          x : int
          y : int
          p : int
          address : int
              The address at which to start reading the data.
          length_bytes : int
              The number of bytes to read from memory. Large reads are
              transparently broken into multiple SCP read commands.
  
          Returns
          -------
          :py:class:`bytes`
              The data is read back from memory as a bytestring.
          """
          # Prepare the buffer to receive the incoming data
          data = bytearray(length_bytes)
          mem = memoryview(data)
  
          # Create a callback which will write the data from a packet into a
          # memoryview.
          def callback(mem, data):
              mem[:] = data[6 + consts.SDP_HEADER_LENGTH:]
  
          # Create a generator that will generate request packets and store data
          # until all data has been returned
          def packets(length_bytes, data):
              offset = 0
              while length_bytes > 0:
                  # Get the next block of data
                  block_size = min((length_bytes, buffer_size))
                  read_address = address + offset
                  dtype = consts.address_length_dtype[(read_address % 4,
                                                       block_size % 4)]
  
                  # Create the call spec and yield
                  yield scpcall(
                      x, y, p, consts.SCPCommands.read, read_address,
                      block_size, dtype,
                      callback=functools.partial(callback,
                                                 mem[offset:offset + block_size])
                  )
  
                  # Update the number of bytes remaining and the offset
                  offset += block_size
                  length_bytes -= block_size
  
          # Run the event loop and then return the retrieved data
          self.send_scp_burst(buffer_size, window_size,
                              list(packets(length_bytes, data)))
          return bytes(data)