Return a HeaderSet excluding the headers in the exclude list.
979230
def filter(self, exclude):
        """"""
        filtered_headers = HeaderDict()
        lowercased_ignore_list = [x.lower() for x in exclude]

        for header, value in iteritems(self):
            if header.lower() not in lowercased_ignore_list:
                filtered_headers[header] = value

        return filtered_headers
420060
public Enumeration<String> getHeaders(String name)
  {
    String value = header(name);
    
    if (value == null) {
      return Collections.emptyEnumeration();
    }

    ArrayList<String> list = new ArrayList<String>();
    list.add(value);

    return Collections.enumeration(list);
  }
360373
public void setHeaders(final Set<String> names) {
        // transform to lower-case because header names should be case-insensitive
        Set<String> lowerCaseNames = new HashSet<>();
        for (String name: names) {
            lowerCaseNames.add(name.toLowerCase());
        }
        this.headerNames = lowerCaseNames;
    }
1249599
private static Set<String> excludedMethods(String... methodNames)
   {
      Set<String> set = new HashSet<String>(MpxjTreeNode.DEFAULT_EXCLUDED_METHODS);
      set.addAll(Arrays.asList(methodNames));
      return set;
   }
23408
function lowerCaseHeaders(headers) {
	var res = {};

	Object.keys(headers).forEach(headerName => {
		res[headerName.toLowerCase()] = headers[headerName];
	});

	return res;
}
828684
def filter_exclude(df, s):
    
    keep = ~np.array( [s in c for c in df.columns.values] )
    return df.iloc[:, keep]
754555
public final B setHeaders(Headers<AsciiString, String, ?> headers) {
        requireNonNull(headers, "headers");
        if (!headers.isEmpty()) {
            getOrCreateHeaders().setAll(headers);
        }
        return self();
    }
405898
def _build_exclusion_list(exclude):
    """"""
    mod_files = []
    if exclude:
        for mod in exclude:
            mdir = None
            mod_file = None
            for token in mod.split("."):
                try:
                    mfile, mdir, _ = imp.find_module(token, mdir and [mdir])
                    if mfile:
                        mod_file = mfile.name
                        mfile.close()
                except ImportError:
                    msg = "Source for module {mod_name} could not be found"
                    raise ValueError(msg.format(mod_name=mod))
            if mod_file:
                mod_files.append(mod_file.replace(".pyc", ".py"))
    return mod_files
89733
def get_filter_fields(self, exclude=None):
        

        exclude_set = set(self.exclude)
        if exclude:
            exclude_set = exclude_set.union(set(exclude))

        return [name for name in self.fields
                if name not in exclude_set]
468888
private function filterHeaders()
    {
        $headers = array();

        foreach ($this->headers as $name => $value) {
            if (strtolower($name) != 'user-agent') {
                $headers[] = "$name: $value";
            }
        }

        return $headers;
    }
55185
def getHeaders(self):
        
        headers = self._impl.getHeaders()
        return tuple(
            headers.getIndex(i) for i in range(self._impl.getNumCols())
        )
827480
def get_request_headers(self, *args, **kwds):
        
        if self.request_headers:
            return self._unpack_headers(self.request_headers)
109418
def get_header(self, header_name, default=None):
        
        return self.headers.get(
            header_name, self.unredirected_headers.get(header_name, default))
629075
public function filterHeaders(&$headers) {
    $unset = array();
    foreach ($headers as $name => $value) {
      $lower = strtolower($name);
      if (isset($this->reservedHeaders[$lower])) {
        $unset[] = $name;
      }
    }
    foreach ($unset as $u) {
      unset($headers[$u]);
    }

    return $this;
  }
473104
def exclude(requestContext, seriesList, pattern):
    
    regex = re.compile(pattern)
    return [s for s in seriesList if not regex.search(s.name)]
43556
def get_headers(hide_env=True):
    """"""

    headers = dict(request.headers.items())

    if hide_env and ('show_env' not in request.args):
        for key in ENV_HEADERS:
            try:
                del headers[key]
            except KeyError:
                pass

    return CaseInsensitiveDict(headers.items())
1225874
def get_header_by_name(self, hdrname):
        '''
        
        '''
        for hdr in self._headers:
            if hdr.__class__.__name__ == hdrname:
                return hdr
        return None