code: def filter(self, func, dropna=True, *args, **kwargs):  # noqa
          
  
          indices = []
  
          obj = self._selected_obj
          gen = self.grouper.get_iterator(obj, axis=self.axis)
  
          for name, group in gen:
              object.__setattr__(group, 'name', name)
  
              res = func(group, *args, **kwargs)
  
              try:
                  res = res.squeeze()
              except AttributeError:  # allow e.g., scalars and frames to pass
                  pass
  
              # interpret the result of the filter
              if is_bool(res) or (is_scalar(res) and isna(res)):
                  if res and notna(res):
                      indices.append(self._get_index(name))
              else:
                  # non scalars aren't allowed
                  raise TypeError("filter function returned a %s, "
                                  "but expected a scalar bool" %
                                  type(res).__name__)
  
          return self._apply_filter(indices, dropna)
docs: Return a copy of a DataFrame excluding elements from groups that
          do not satisfy the boolean criterion specified by func.
  
          Parameters
          ----------
          f : function
              Function to apply to each subframe. Should return True or False.
          dropna : Drop groups that do not pass the filter. True by default;
              if False, groups that evaluate False are filled with NaNs.
  
          Returns
          -------
          filtered : DataFrame
  
          Notes
          -----
          Each subframe is endowed the attribute 'name' in case you need to know
          which group you are working on.
  
          Examples
          --------
          >>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
          ...                           'foo', 'bar'],
          ...                    'B' : [1, 2, 3, 4, 5, 6],
          ...                    'C' : [2.0, 5., 8., 1., 2., 9.]})
          >>> grouped = df.groupby('A')
          >>> grouped.filter(lambda x: x['B'].mean() > 3.)
               A  B    C
          1  bar  2  5.0
          3  bar  4  1.0
          5  bar  6  9.0