Parameters:
     - messages
436575
def Log(self, messages):
    
    self._seqid += 1
    d = self._reqs[self._seqid] = defer.Deferred()
    self.send_Log(messages)
    return d
568242
def direct_messages(self, delegate, params={}, extra_args=None):
        """"""
        return self.__get('/direct_messages.xml', delegate, params,
                          txml.Direct, extra_args=extra_args)
1329599
def message_cli(subject, message_body, access_token, all_members=False,
                project_member_ids=None, base_url=OH_BASE_URL,
                verbose=False, debug=False):
    
    if project_member_ids:
        project_member_ids = re.split(r'[ ,\r\n]+', project_member_ids)
    return message(subject, message_body, access_token, all_members,
                   project_member_ids, base_url)
120238
def send_messages(self, messages):
        
        if not messages:
            return
        new_conn_created = self.open()
        if not self.connection:
            # We failed silently on open(). Trying to send would be pointless.
            return
        num_sent = 0
        for message in messages:
            sent = self._send(message)
            if sent:
                num_sent += 1
        if new_conn_created:
            self.close()
        return num_sent
113928
def messages
      result = []
      seen = {}
      descriptors.each do |d|
        dm = d.messages
        dm.delete_if do |m|
          delete = seen[m.name]
          seen[m.name] = true
          delete
        end
        result.concat dm
      end
      result.sort!
    end
1241551
def full_messages
      inject([]) do |m, kv|
        att, errors = *kv
        errors.each {|e| m << "#{e}"}
        m
      end
    end
163387
def handle_message(self, msg):
        
        self._messages.append({
            'type': msg.category,
            'module': msg.module,
            'obj': msg.obj,
            'line': msg.line,
            'column': msg.column,
            'path': msg.path,
            'symbol': msg.symbol,
            'message': str(msg.msg) or '',
            'message-id': msg.msg_id,
        })
434972
def on_message(self, message):
        
        log.debug("WS MSG for %s: %s" % (self._get_sess_id(), message))
        self.application.pc.redirect_incoming_message(self._get_sess_id(), message, self.request)
829418
@Override
    public Message newMessage(final String message, final Object... params) {
        if (params == null) {
            return new SimpleMessage(message);
        }
        final ParameterizedMessage msg = new ParameterizedMessage(message, params);
        return new StatusMessage(msg.getFormattedMessage(), msg.getThrowable());
    }
1268736
async def root_message(self, msg, msg_type=None):
        
        await self.root()
        await self.message(msg, msg_type)
1178912
@Override
    public Message newMessage(final String message, final Object... params) {
        return new FormattedMessage(message, params);
    }
33879
def messages(self):
        
        if self._messages is None:
            self._messages = MessageList(self._version, account_sid=self._solution['sid'], )
        return self._messages
572399
def messages(self):
        ''''''

        # The file contains the fixed-size file header followed by
        # fixed-size message structures, followed by minimal message
        # information (subject, from, to).  Start after the file
        # header and then simply return the message structures in
        # sequence until we have returned the number of messages in
        # this folder, ignoring the minimal message information at the
        # end of the file.

        offset = self.header_length # initial offset
        # how much of the data in this file we expect to use, based on
        # the number of messages in this folder and the index message block size
        maxlen = self.header_length + self.total_messages * MacIndexMessage.LENGTH
        while offset < maxlen:
             yield MacIndexMessage(mm=self.mmap, offset=offset)
             offset += MacIndexMessage.LENGTH
755556
def show_messages(self):
        """"""
        string = ''
        if self.static_message is not None:
            string += self.static_message.to_text()

        for message in self.dynamic_messages:
            string += message.to_text()

        print(string)
819323
def dump(cls, message):
        
        if cls.verbose > 2:
            msg = '[DUMP] %s' % message
            cls.echo(msg)
814879
def info(*messages):
    
    sys.stderr.write("%s.%s: " % get_caller_info())
    sys.stderr.write(' '.join(map(str, messages)))
    sys.stderr.write('\n')
319988
def message_options(self):
        
        o = {}
        options = self.options
        for key in self._default_message_options:
            if key in options:
                o[key] = options[key]
        return o