Send a number of frames.
434828
def send(self, *args):
        
        for frame in args:
            self.sock.sendall(self.apply_send_hooks(frame, False).pack())
769331
def send_bytes(self):
        """"""
        data = b''.join(self.bytes_to_send)
        self.bytes_to_send = []
        return data
615344
def send(self_p, dest, flags):
        
        return lib.zframe_send(byref(zframe_p.from_param(self_p)), dest, flags)
1292103
def send(self, data):
        '''
        
        '''
        self._vcr_request.body = self._vcr_request.body + data \
            if self._vcr_request.body else data
599057
async def _fair_send(self, frames):
        
        peer = await self._fair_get_out_peer()
        peer.outbox.write_nowait(frames)
        return peer
1237150
def send(self, data):
        """"""
        self._send_data(int_to_hex(len(data)))

        self._send_data(data)
59086
def _send(self, data):
        """"""
        try:
            self._sock.sendto(data.encode('ascii'), self._addr)
        except (socket.error, RuntimeError):
            # No time for love, Dr. Jones!
            pass
63819
def send_data(data = "", end_stream: true)
      max = @connection.remote_settings[:max_frame_size]
      if data.is_a?(IO)
        until data.eof?
          fragment = data.readpartial(max)
          send Frame::Data.new(id, fragment, end_stream: end_stream && data.eof?)
        end
      else
        send Frame::Data.new(id, data, end_stream: end_stream)
      end
      @state = :half_closed_local if end_stream
    end
867512
def pause(self, pause=0):
        """"""
        fr = self.frames[-1]
        n = int(self.fps * pause)
        for i in range(n):
            fr2 = "/tmp/vpvid/" + str(len(self.frames)) + ".png"
            self.frames.append(fr2)
            os.system("cp -f %s %s" % (fr, fr2))
1252445
def write_frames(self, channel_id, frames_out):
        
        data_out = EMPTY_BUFFER
        for single_frame in frames_out:
            data_out += pamqp_frame.marshal(single_frame, channel_id)
        self.heartbeat.register_write()
        self._io.write_to_socket(data_out)
1284671
def addFrame(self):
        """"""
        fr = "/tmp/vpvid/" + str(len(self.frames)) + ".png"
        screenshot(fr)
        self.frames.append(fr)
789690
def send(self, payload, opcode=ABNF.OPCODE_TEXT):
        

        frame = ABNF.create_frame(payload, opcode)
        return self.send_frame(frame)
1280343
def _flush_buffered_frames(self):
        '''
        
        '''
        # In the rare case (a bug) where this is called but send_frame thinks
        # they should be buffered, don't clobber.
        frames = self._output_frame_buffer
        self._output_frame_buffer = []
        for frame in frames:
            self.send_frame(frame)
620191
def send_frame(self, message, opcode):
        
        if self._closed:
            raise WebSocketError("Connection is already closed")
        if opcode == self.OPCODE_TEXT:
            message = self._encode_bytes(message)
        elif opcode == self.OPCODE_BINARY:
            message = six.binary_type(message)
        header = Header.encode_header(True, opcode, '', len(message), 0)
        try:
            self.stream.write(header + message)
        except socket_error:
            raise WebSocketError("Socket is dead")
935167
def send(self, data):
        """"""
        # send message
        _LOGGER.debug("send: " + data)
        self.socket.send(data.encode('ascii'))
        # sleep needed to prevent flooding the GC100 with sends
        sleep(.01)
1113718
def send(self, change):
        """"""
        self.buf.append(change)
        if len(self.buf) % self.BUF_SIZE == 0:
            self.flush()
497759
def _send_tune_ok(self, frame_in):
        
        self.max_allowed_channels = self._negotiate(frame_in.channel_max,
                                                    MAX_CHANNELS)
        self.max_frame_size = self._negotiate(frame_in.frame_max,
                                              MAX_FRAME_SIZE)
        LOGGER.debug(
            'Negotiated max frame size %d, max channels %d',
            self.max_frame_size, self.max_allowed_channels
        )

        tune_ok_frame = specification.Connection.TuneOk(
            channel_max=self.max_allowed_channels,
            frame_max=self.max_frame_size,
            heartbeat=self._heartbeat)
        self._write_frame(tune_ok_frame)