(-) `:not(panda)`
345165
function getPseudoClass1() {
  const type = NodeType.PseudocType;
  const token = tokens[pos];
  const line = token.ln;
  const column = token.col;
  const content = [];

  // Skip `:`.
  pos++;

  content.push(getIdent());

  {
    const type = NodeType.ArgumentsType;
    const token = tokens[pos];
    const line = token.ln;
    const column = token.col;

    // Skip `(`.
    pos++;

    const selectorContent = [].concat(
      getSC(),
      getSelectorsGroup(),
      getSC()
    );

    const end = getLastPosition(selectorContent, line, column, 1);
    const args = newNode(type, selectorContent, line, column, end);
    content.push(args);

    // Skip `)`.
    pos++;
  }

  return newNode(type, content, line, column);
}
634647
def not_a_string(obj):
    """"""
    my_type = str(type(obj))
    if is_py3():
        is_str = my_type.find('bytes') < 0 and my_type.find('str') < 0
        return is_str

    return my_type.find('str') < 0 and \
        my_type.find('unicode') < 0
31820
def filter_nan(s, o):
    
    data = np.array([s.flatten(), o.flatten()])
    data = np.transpose(data)
    data = data[~np.isnan(data).any(1)]
    return data[:, 0], data[:, 1]
990319
def is_dataframe(data):
    
    dd = None
    if 'dask' in sys.modules and 'pandas' in sys.modules:
        import dask.dataframe as dd
    return((pd is not None and isinstance(data, pd.DataFrame)) or
          (dd is not None and isinstance(data, dd.DataFrame)))
510839
def to_native_types(self, slicer=None, na_rep='nan', quoting=None,
                        **kwargs):
        

        values = self.get_values()

        if slicer is not None:
            values = values[:, slicer]
        mask = isna(values)

        if not self.is_object and not quoting:
            values = values.astype(str)
        else:
            values = np.array(values, dtype='object')

        values[mask] = na_rep
        return values
244646
def reject(lst, *values):
    """"""
    lst = List.from_maybe(lst)
    values = frozenset(List.from_maybe_starargs(values))

    ret = []
    for item in lst:
        if item not in values:
            ret.append(item)
    return List(ret, use_comma=lst.use_comma)
374597
def _remove_nonascii(self, df):
    """"""

    df_copy = df.copy(deep=True)
    for col in df_copy.columns:
      if (df_copy[col].dtype == np.dtype('O')):
        df_copy[col] = df[col].apply(
          lambda x: re.sub(r'[^\x00-\x7f]', r'', x) if isinstance(x, six.string_types) else x)

    return df_copy
868152
def _print_unhashable(df, columns=None):
    
    for c in df.columns if columns is None else columns:
        if df.dtypes[c] == object:
            try:
                df[c].apply(hash)
            except TypeError:
                df[c] = df[c].dropna().apply(pformat).ix[df.index]

    return df
1215277
def _filter_none(items):
    """"""
    type_ = list if isinstance(items, list) else tuple
    return type_(filter(_not_none, items))
1018769
def isNumber(s):
    
    s = s.replace(',', '')
    try:
        float(s)
        return True
    except ValueError:
        pass
    try:
        import unicodedata
        unicodedata.numeric(s)
        return True
    except (TypeError, ValueError) as e:
        pass
    return False
1357595
def no_camel(name):
    
    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
515756
def filter_not_t(func):
    
    return Transformation('filter_not({0})'.format(name(func)),
                          partial(six.moves.filterfalse, func),
                          {ExecutionStrategies.PARALLEL})
929147
def none_missing(df, columns=None):
    
    if columns is None:
        columns = df.columns
    assert not df[columns].isnull().any().any()
    return df
1234829
def gmean_(self, col: str, index_col: bool=True) -> "Ds":
        
        try:
            df = self.df.copy()
            df = df.groupby([col]).mean()
            if index_col is True:
                df[col] = df.index.values
            return self._duplicate_(df)
        except Exception as e:
            self.err(e, self.gmean_, "Can not meansum column")
529058
def not_files(self):
        """"""

        _args = []

        for arg in self.all:
            if not len(expand_path(arg)):
                if not os.path.exists(arg):
                    _args.append(arg)

        return Args(_args, no_argv=True)
26655
def _judeNOtIn(self, raw_str, ele_list):
        '''
        
        '''
        for ele in ele_list:
            if ele in raw_str:
                return False
        return True
375351
def drop_nan_columns(df, thresh=325):
    
    if thresh < 1:
        thresh = int(thresh * df)
    return df.dropna(axis=1, thresh=thresh, inplace=False)