Dumps the return value
        :param ret:
        :return:
420378
def dump(self, ret):
        
        if self.args.flatten:
            ret = drop_none(flatten(ret))

        logger.info('Dump: \n' + json.dumps(ret, cls=AutoJSONEncoder, indent=2 if self.args.indent else None))
603775
def return_value(self, *args, **kwargs):
        

        self._called()
        return self._return_value(*args, **kwargs)
789001
def dumps(self):
        """"""

        ret_str = self.path_type

        if self.options is not None:
            ret_str += self.options.dumps()

        return ret_str
1291486
def returner(ret):
    '''
    
    '''
    log.debug('sqlite3 returner <returner> called with data: %s', ret)
    conn = _get_conn(ret)
    cur = conn.cursor()
    sql = '''INSERT INTO salt_returns
             (fun, jid, id, fun_args, date, full_ret, success)
             VALUES (:fun, :jid, :id, :fun_args, :date, :full_ret, :success)'''
    cur.execute(sql,
                {'fun': ret['fun'],
                 'jid': ret['jid'],
                 'id': ret['id'],
                 'fun_args': six.text_type(ret['fun_args']) if ret.get('fun_args') else None,
                 'date': six.text_type(datetime.datetime.now()),
                 'full_ret': salt.utils.json.dumps(ret['return']),
                 'success': ret.get('success', '')})
    _close_conn(conn)
557079
def dump(self, obj, format=None, *, kwargs={}):
        '''
        
        '''
        return dump(self, obj, format=format, kwargs=kwargs)
576933
def output(ret, bar, **kwargs):  # pylint: disable=unused-argument
    '''
    
    '''
    if 'return_count' in ret:
        val = ret['return_count']
        # Avoid to fail if targets are behind a syndic. In this case actual return count will be
        # higher than targeted by MoM itself.
        # TODO: implement a way to get the proper target minions count and remove this workaround.
        # Details are in #44239.
        if val > bar.maxval:
            bar.maxval = val
        bar.update(val)
    return ''
1124395
def dump(self, f):
        
        ret = libxml2mod.xmlDocDump(f, self._o)
        return ret
974586
def returner(ret):
    '''
    
    '''
    conn = _get_conn(ret)
    cur = conn.cursor()
    sql = '''INSERT INTO salt_returns
            (fun, jid, retval, id, success, full_ret)
            VALUES (?, ?, ?, ?, ?, ?)'''
    cur.execute(
        sql, (
            ret['fun'],
            ret['jid'],
            salt.utils.json.dumps(ret['return']),
            ret['id'],
            ret['success'],
            salt.utils.json.dumps(ret)
        )
    )
    _close_conn(conn)
928726
def returner(ret):
    '''
    
    '''
    serv = _get_serv(ret)
    minion = ret['id']
    jid = ret['jid']
    fun = ret['fun']
    rets = salt.utils.json.dumps(ret)
    serv.set('{0}:{1}'.format(jid, minion), rets)  # cache for get_jid
    serv.set('{0}:{1}'.format(fun, minion), rets)  # cache for get_fun

    # The following operations are neither efficient nor atomic.
    # If there is a way to make them so, this should be updated.
    _append_list(serv, 'minions', minion)
    _append_list(serv, 'jids', jid)
539749
def save(self, clean=True):
        
        ret = {}
        if clean:
            self._dirty = False
        else:
            ret['_dirty'] = self._dirty
        return ret
1029300
def dumps(o, **kwargs):
    """"""

    try:
        return _engine[1](o)

    except:
        ExceptionClass, why = sys.exc_info()[:2]

        if any([(issubclass(ExceptionClass, e)) for e in _engine[2]]):
            raise JSONError(why)
        else:
            raise why
982715
def dump(node):
    
    def _format(node):
        if isinstance(node, AST):
            return '%s(%s)' % (node.__class__.__name__,
                               ', '.join('%s=%s' % (a, _format(b))
                                         for a, b in iter_fields(node)))
        elif isinstance(node, list):
            return '[%s]' % ', '.join(_format(x) for x in node)
        return repr(node)
    if not isinstance(node, AST):
        raise TypeError('expected AST, got %r' % node.__class__.__name__)
    return _format(node)
1080061
def dumpu(self, data, url, **kwargs):
        
        return self.dump(data, self.open(url, 'w', **kwargs), **kwargs)
941785
def return_pub(self, ret):
        '''
        
        '''
        channel = salt.transport.client.ReqChannel.factory(self.opts, usage='salt_call')
        load = {'cmd': '_return', 'id': self.opts['id']}
        for key, value in six.iteritems(ret):
            load[key] = value
        try:
            channel.send(load)
        finally:
            channel.close()
1065812
def dump_ast(ast, indent=' ', newline='\n'):
    '''
    
    
    
    '''
    
    visitor = ASTPrinter(indent=indent, level=0, newline=newline)
    visitor.visit(ast)
    return visitor.dumps()
330731
def _write(self, ret):
        
        self.redis.set('{0}:{1}'.format(ret['id'], ret['jid']), json.dumps(ret))
        self.redis.lpush('{0}:{1}'.format(ret['id'], ret['fun']), ret['jid'])
        self.redis.sadd('minions', ret['id'])
        self.redis.sadd('jids', ret['jid'])
82967
def dump(self, fh, value, context=None):
		
		
		value = self.dumps(value)
		fh.write(value)
		return len(value)