Send data to gmond.
772786
def _send(self, metric):
        
        metric_name = self.get_name_from_path(metric.path)
        tmax = "60"
        dmax = "0"
        slope = "both"
        # FIXME: Badness, shouldn't *assume* double type
        metric_type = "double"
        units = ""
        group = ""
        self.gmetric.send(metric_name,
                          metric.value,
                          metric_type,
                          units,
                          slope,
                          tmax,
                          dmax,
                          group)
1032704
def SendVerack(self):
        """"""
        m = Message('verack')
        self.SendSerializedMessage(m)
        self.expect_verack_next = True
751643
def send(self, message, level=Level.NOTICE):
    ""
    data = "<%d>%s" % (level + self.facility*8, message)
    if self.protocol == 'UDP':
        self.socket.sendto(data.encode('utf-8'), (self.host, self.port))
    else:
        self.socket.send(data.encode('utf-8'))
338220
def send(self, data):
        
        self.future_session.post(url=self.url, data=data)
154657
def send_multipart(self, *args, **kwargs):
        """"""
        self.__in_send_multipart = True
        try:
            msg = super(GreenSocket, self).send_multipart(*args, **kwargs)
        finally:
            self.__in_send_multipart = False
            self.__state_changed()
        return msg
1172048
def _hm_send_msg(self, message):
        """"""
        try:
            serial_message = message
            self.conn.write(serial_message)   # Write a string
        except serial.SerialTimeoutException:
            serror = "Write timeout error: \n"
            sys.stderr.write(serror)
        # Now wait for reply
        byteread = self.conn.read(159)
        # NB max return is 75 in 5/2 mode or 159 in 7day mode
        datal = list(byteread)
        return datal
786684
def send_email(self, user, subject, msg):
        """"""
        print('To:', user)
        print('Subject:', subject)
        print(msg)
393906
def send_to_websocket(self, data):
        """"""
        data = json.dumps(data)
        self.websocket.send(data)
1300789
def send(self, data):
        """"""
        log.debug('Sending %s' % data)
        if not self._socket:
            log.warn('No connection')
            return
        self._socket.send_bytes(data.encode('utf-8'))
327565
def send(self, data, room=None, include_self=True, namespace=None,
             callback=None):
        """"""
        return self.socketio.send(data, room=room, include_self=include_self,
                                  namespace=namespace or self.namespace,
                                  callback=callback)
405048
def _send(self, data):
        """"""
        if not self._sock:
            self.connect()
        self._do_send(data)
297435
def sendAZ(self, az):
        '''
        

        '''
        self.lock.acquire()
        self.data.az = az
        self.lock.release()
520469
def _send(self, message):
        """"""
        charset='UTF-8'
        params = {
          'action' : 'sendsms',
          'user' : self.get_username(),
          'password' : self.get_password(),
          'from' : message.from_phone,
          'to' : ",".join(message.to),
          'text' : message.body,
          'clientcharset' : charset,
          'detectcharset' : 1,
          'maxsplit': int(math.ceil(len(message.body) / 160))
        }
        
        req = urllib2.Request(SMSGLOBAL_API_URL_SENDSMS, urllib.urlencode(params))
        result_page = urllib2.urlopen(req).read()
        results = self._parse_response(result_page)
        
        if results is None:
            if not self.fail_silently:
                raise Exception("Error determining response: [" + result_page + "]")
            return False
        
        code, sendqmsgid, msgid = results
        
        if code != '0':
            if not self.fail_silently:
                raise Exception("Error sending sms: [%s], extracted results(code, sendqmsgid, msgid): [%s]" % (result_page, results))
            return False
        else:
            logger.info('SENT to: %s; sender: %s; code: %s; sendqmsgid: %s; msgid: %s; message: %s' % (
                message.to,
                message.from_phone,
                code, 
                sendqmsgid, 
                msgid,
                message.body
            ))
            return True
1196184
def send(transport, time, state, host, description, service, tag, attribute,
         ttl, metric_f, echo):
    """"""
    client = CommandLineClient(transport)
    event = client.create_event({
        'time': time,
        'state': state,
        'host': host,
        'description': description,
        'service': service,
        'tags': tag,
        'attributes': dict(attribute),
        'ttl': ttl,
        'metric_f': metric_f
    })

    with client:
        client.send_event(event)
    if echo:
        echo_event(client.create_dict(event))
204487
def send(self, msg_dict):
        """"""
        message = ejson.dumps(msg_dict)
        super(DDPSocket, self).send(message)
        self._debug_log('<<<{}'.format(message))
681141
def sendfile(self, data, zlib_compress=None, compress_level=6):
        """"""
        if hasattr(data, 'seek'):
            data.seek(0)

        chunk_size = CHUNK_SIZE

        if zlib_compress:
            chunk_size = BLOCK_SIZE
            compressor = compressobj(compress_level)

        while 1:
            binarydata = data.read(chunk_size)
            if binarydata == '':
                break
            if zlib_compress:
                binarydata = compressor.compress(binarydata)
                if not binarydata:
                    continue
            self.send(binarydata)

        if zlib_compress:
            remaining = compressor.flush()
            while remaining:
                binarydata = remaining[:BLOCK_SIZE]
                remaining = remaining[BLOCK_SIZE:]
                self.send(binarydata)
798128
def sendfrom(self, account, address, amount):
        """"""
        return self.req("sendfrom", [account, address, amount])