docs: def write(self, buffer_size, window_size, x, y, p, address, data):
          """Write a bytestring to 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 will be
              written in each packet.
          window_size : int
          x : int
          y : int
          p : int
          address : int
              The address at which to start writing the data. Addresses are given
              within the address space of a SpiNNaker core. See the SpiNNaker
              datasheet for more information.
          data : :py:class:`bytes`
              Data to write into memory. Writes are automatically broken into a
              sequence of SCP write commands.
          """
          # While there is still data perform a write: get the block to write
          # this time around, determine the data type, perform the write and
          # increment the address
          def packets(address, data):
              end = len(data)
              pos = 0
              while pos < end:
                  block = data[pos:pos + buffer_size]
                  block_size = len(block)
  
                  dtype = consts.address_length_dtype[(address % 4,
                                                       block_size % 4)]
  
                  yield scpcall(x, y, p, consts.SCPCommands.write, address,
                                block_size, dtype, block)
  
                  address += block_size
                  pos += block_size
  
          # Run the event loop and then return the retrieved data
          self.send_scp_burst(buffer_size, window_size,
                              list(packets(address, data)))