code: def _find_exclude_filter(cls, excludes, item):
          
          # if exclude is left blank (not a list) then the predicate will just
          # be true
          if excludes is None:
              return False
  
          # oh my...
          def test_each_exclude(exclude_value):
              # excluded_value is one of excludes = (...,)
              def exclude_equals_value_test(exclude_filter):
                  # exclude_filter is one of EXCLUDE_FILTERS = (...,)
                  if callable(exclude_filter):
                      return exclude_filter(cls, item, exclude_value,)
                  return item.get(exclude_filter) == exclude_value
              return any(map(exclude_equals_value_test, cls.EXCLUDE_FILTERS))
          return any(map(test_each_exclude, excludes))
docs: For each item returned by a `find()` maybe filter it out.
  
          Called for each item returned to find a function or string to exclude
          `item` from a filtered list. This method should return truthy values
          where `True`-like values will allow `item` to be included into the
          set, and `False` values will not allow them into the set (filter
          predicate).
  
          This is a dynamic filtering method such that users of the library
          will be able to do something like:
  
          Class.find(exclude=('email@address.com', 1,))
  
          Where the coreesponding EXCLUDE_FILTERS = ('email', 'id',). Similar to
          matching any value on any indexed field, where EXCLUDE_FILTERS are the
          indexes.
  
          XXX: Even explaining this was difficult. Probably an easier more
          pragmatic way to do this.