Returns the outputters modules

    :param dict opts: The Salt options dictionary
    :returns: LazyLoader instance, with only outputters present in the keyspace
512231
def outputters(opts):
    '''
    
    '''
    ret = LazyLoader(
        _module_dirs(opts, 'output', ext_type_dirs='outputter_dirs'),
        opts,
        tag='output',
    )
    wrapped_ret = FilterDictWrapper(ret, '.output')
    # TODO: this name seems terrible... __salt__ should always be execution mods
    ret.pack['__salt__'] = wrapped_ret
    return wrapped_ret
779169
def engines(opts, functions, runners, utils, proxy=None):
    '''
    
    '''
    pack = {'__salt__': functions,
            '__runners__': runners,
            '__proxy__': proxy,
            '__utils__': utils}
    return LazyLoader(
        _module_dirs(opts, 'engines'),
        opts,
        tag='engines',
        pack=pack,
    )
22125
function (opts) {
            var m = this.outputIdentifierFunc;
            return this.metadataDataset.withSql('SHOW TABLES').map(function (r) {
                return m(r[Object.keys(r)[0]]);
            });
        }
484883
function getOptions(opts) {
  var options = {};
  for (var opt in defaultOptions) {
    options[opt] = opts && _util.has(opts, opt) ? opts[opt] : defaultOptions[opt];
  }if (options.allowReserved == null) options.allowReserved = options.ecmaVersion < 5;

  if (_util.isArray(options.onToken)) {
    (function () {
      var tokens = options.onToken;
      options.onToken = function (token) {
        return tokens.push(token);
      };
    })();
  }
  if (_util.isArray(options.onComment)) options.onComment = pushComment(options, options.onComment);

  return options;
}
435345
function (opts) {
            opts.meta.classes = [];
            Y.each(this.data.classes, function (v) {
                if (v.external) {
                    return;
                }
                opts.meta.classes.push({
                    displayName: v.name,
                    name: v.name,
                    namespace: v.namespace,
                    module: v.module,
                    description: v.description,
                    access: v.access || 'public'
                });
            });
            opts.meta.classes.sort(this.nameSort);
            return opts;
        }
944550
def get_output_dict(stack):
    
    outputs = {}
    if 'Outputs' not in stack:
        return outputs

    for output in stack['Outputs']:
        logger.debug("    %s %s: %s", stack['StackName'], output['OutputKey'],
                     output['OutputValue'])
        outputs[output['OutputKey']] = output['OutputValue']
    return outputs
390089
def __prep_mod_opts(self, opts):
        '''
        
        '''
        if '__grains__' not in self.pack:
            grains = opts.get('grains', {})

            if isinstance(grains, ThreadLocalProxy):
                grains = ThreadLocalProxy.unproxy(grains)

            self.context_dict['grains'] = grains
            self.pack['__grains__'] = salt.utils.context.NamespacedDictWrapper(self.context_dict, 'grains')

        if '__pillar__' not in self.pack:
            pillar = opts.get('pillar', {})

            if isinstance(pillar, ThreadLocalProxy):
                pillar = ThreadLocalProxy.unproxy(pillar)

            self.context_dict['pillar'] = pillar
            self.pack['__pillar__'] = salt.utils.context.NamespacedDictWrapper(self.context_dict, 'pillar')

        mod_opts = {}
        for key, val in list(opts.items()):
            if key == 'logger':
                continue
            mod_opts[key] = val
        return mod_opts
735781
function getTransformers (opts) {
  var cwd = opts.basedir || process.cwd()
  var transforms = [].concat(opts.transform).filter(Boolean)
  return transforms.map(function (item) {
    // support [ 'brfs', {} ] and 'brfs'
    var transform
    var transformOpts = {}
    if (Array.isArray(item)) {
      transform = item[0]
      transformOpts = item[1] || {}
    } else {
      transform = item
    }
    if (typeof transform === 'string') {
      // resolve module names like in browserify
      var file = resolve.sync(transform, {
        basedir: cwd
      })
      transform = require(file)
      if (typeof transform !== 'function') {
        throw new Error(
          'Transform at ' + file + ' must export a function'
        )
      }
    } else if (typeof transform !== 'function') {
      throw new Error(
        'Expected string or function for transform, got ' + item
      )
    }
    return [ transform, transformOpts ]
  })
}
616014
def _make_opt_list(opts, group):
    
    import copy
    import itertools

    _opts = [(group, list(itertools.chain(*opts)))]
    return [(g, copy.deepcopy(o)) for g, o in _opts]
1339853
def _get_options(ret=None):
    '''
    
    '''
    attrs = {
        'api_token': 'api_token',
        'api_url': 'api_url',
        'tags': 'tags',
        'sls_states': 'sls_states'
    }

    _options = salt.returners.get_returner_options(
        __virtualname__,
        ret,
        attrs,
        __salt__=__salt__,
        __opts__=__opts__)

    _options['api_url'] = _options.get('api_url', 'api.appoptics.com')
    _options['sls_states'] = _options.get('sls_states', [])
    _options['tags'] = _options.get('tags', {
        'host_hostname_alias': __salt__['grains.get']('id')
    })

    log.debug('Retrieved appoptics options: %s', _options)
    return _options
16545
function defaults(opts) {
  opts = opts || {}

  if (!opts.streamer) {
    throw new Error('No streamer found. Must pass a streamer to multipart-pipe')
  }

  opts.limit = opts.limit === undefined ? '128mb' : opts.limit;
  opts.limit = typeof opts.limit === 'string' ? parseBytes(opts.limit) : opts.limit;
  opts.allow = opts.allow instanceof RegExp ? opts.allow : new RegExp(opts.allow || '.*');

  if (!opts.filename || typeof opts.filename !== 'function') {
    opts.filename = function (filename, mime) { return filename; };
  }

  return opts
}
154127
def _prep_mod_opts(self):
        '''
        
        '''
        mod_opts = {}
        for key, val in six.iteritems(self.opts):
            if key == 'logger':
                continue
            mod_opts[key] = val
        return mod_opts
597111
def modules():
    '''
    
    '''
    cmd = '{0} -M'.format(_detect_os())
    ret = {}
    ret['static'] = []
    ret['shared'] = []
    out = __salt__['cmd.run'](cmd).splitlines()
    for line in out:
        comps = line.split()
        if not comps:
            continue
        if '(static)' in line:
            ret['static'].append(comps[0])
        if '(shared)' in line:
            ret['shared'].append(comps[0])
    return ret
130588
def add_multiifo_output_list_opt(self, opt, outputs):
        
        # NOTE: Here we have to use the raw arguments functionality as the
        #       file and ifo are not space separated.
        self.add_raw_arg(opt)
        self.add_raw_arg(' ')
        for outfile in outputs:
            self.add_raw_arg(outfile.ifo)
            self.add_raw_arg(':')
            self.add_raw_arg(outfile.name)
            self.add_raw_arg(' ')
            self._add_output(outfile)
564942
def clouds(opts):
    '''
    
    '''
    # Let's bring __active_provider_name__, defaulting to None, to all cloud
    # drivers. This will get temporarily updated/overridden with a context
    # manager when needed.
    functions = LazyLoader(
        _module_dirs(opts,
                     'clouds',
                     'cloud',
                     base_path=os.path.join(SALT_BASE_PATH, 'cloud'),
                     int_type='clouds'),
        opts,
        tag='clouds',
        pack={'__utils__': salt.loader.utils(opts),
              '__active_provider_name__': None},
    )
    for funcname in LIBCLOUD_FUNCS_NOT_SUPPORTED:
        log.trace(
            '\'%s\' has been marked as not supported. Removing from the '
            'list of supported cloud functions', funcname
        )
        functions.pop(funcname, None)
    return functions
421672
def pkgdb(opts):
    '''
    
    '''
    return LazyLoader(
        _module_dirs(
            opts,
            'pkgdb',
            base_path=os.path.join(SALT_BASE_PATH, 'spm')
        ),
        opts,
        tag='pkgdb'
    )
1041992
def _get_defaults(modules):
    
    default = os.path.join(os.path.dirname(__file__),
                           'defaults/%s.yaml' % (modules))
    return yaml.safe_load(open(default))