Return options for names and remove it from given options in-place.
778872
def extract_options(options, names):
    
    result = {}
    for name, value in copy(options).items():
        if name in names:
            result[name] = value
            del options[name]
    return result
365783
def remove_entry_points(self, names):
        
        names = util.return_set(names)
        util.remove_from_set(self.entry_point_names,
                             names)
1104015
def remove_all(self):
        """"""
        names = sorted(self._actions_dict.keys())
        for name in names:
            self.remove(name)
536016
def remove_defaults(self, *args):
        '''
        
        '''
        rms = set(arg for aa in args for arg in ([aa] if isinstance(aa, six.string_types) else aa))
        for arg in rms:
            if arg not in self.defaults:
                raise KeyError('{0}'.format(arg))
        return self.discard_defaults(*args)
1300871
def options(cls):
        """"""
        return sorted((value, name) for (name, value) in cls.__dict__.items() if not name.startswith('__'))
1030554
public function cleanOptions($options = [])
    {
        // If item is null or empty we will remove them.
        return collect($options)->reject(function ($item) {
            return empty($item) || is_null($item);
        })->all();
    }
1163744
function cleanupArray(obj, name) {
    var arr = obj[name];
    if (!arr) throw new Error(name + ' option is missing');
    if (Array.isArray(arr)) {
      arr = arr.join(',');
    }
    if (typeof arr !== 'string') throw new Error(name + ' option must be an Array or a comma separated String');
    arr = arr.replace(/_/g, '-').replace(/\s/g, '').toLowerCase().split(',');
    return arr;
  }
211463
def remove(self, items):
        """"""
        items = coerce_to_list(items)
        new_options = {k: v for k, v in self.options.items() if v not in items}
        self.widget.options = new_options
        self.widget.param.trigger('options')
335926
def _skip(options):
    """"""
    values = [options.missing_direct_deps, options.unnecessary_deps]
    return all(v == 'off' for v in values)
834795
def clear_option_value(self, opt_name):
        
        if not self.has_option(opt_name):
            raise ValueError("Unknow option name (%s)" % opt_name)
        self._options[opt_name].clear()
1160950
def remove(name):
    '''
    
    '''
    # Putting quotes around the parameter protects against command injection
    cmd = 'Uninstall-Module "{0}"'.format(name)
    no_ret = _pshell(cmd)
    return name not in list_modules()
436149
def remove_aliases(self_or_cls, aliases):
        
        for k,v in self_or_cls.aliases.items():
            if v in aliases:
                self_or_cls.aliases.pop(k)
1208953
def options(cls):
        """"""
        return {k: v for k, v in cls.__dict__.items() if isinstance(v, Option)}
1303605
def _cleanup(self, domains):
        """"""
        for option in domains.values():
            try:
                os.remove(option['pot'])
            except (IOError, OSError):
                # It is not a problem if we can't actually remove the temporary file
                pass
56138
def filter_opt(opt):
    """"""
    return {k: GLib.Variant(*v) for k, v in opt.items() if v[1] is not None}
630063
def cleanOptions(options):
    
    _reload = options.pop('reload')
    dev = options.pop('dev')
    opts = []
    store_true = [
        '--nocache', '--global_cache', '--quiet', '--loud'
    ]
    store_false = []
    for key, value in options.items():
        key = '--' + key
        if (key in store_true and value) or (key in store_false and not value):
            opts += [key, ]
        elif value:
            opts += [key, str(value)]
    return _reload, opts
590181
def extract_options(names)
      options = {}
      options = names.pop if names.last.kind_of? Hash
      options = { :desc => @next_desc, 
                  :long_desc => @next_long_desc,
                  :default_value => @next_default_value,
                  :arg_name => @next_arg_name}.merge(options)
    end