docs: def filter(self, *args, **kwargs):
          """
          Adds WHERE arguments to the queryset, returning a new queryset
  
          #TODO: show examples
  
          :rtype: AbstractQuerySet
          """
          #add arguments to the where clause filters
          if len([x for x in kwargs.values() if x is None]):
              raise CQLEngineException("None values on filter are not allowed")
  
          clone = copy.deepcopy(self)
          for operator in args:
              if not isinstance(operator, WhereClause):
                  raise QueryException('{} is not a valid query operator'.format(operator))
              clone._where.append(operator)
  
          for arg, val in kwargs.items():
              col_name, col_op = self._parse_filter_arg(arg)
              quote_field = True
              #resolve column and operator
              try:
                  column = self.model._get_column(col_name)
              except KeyError:
                  if col_name == 'pk__token':
                      if not isinstance(val, Token):
                          raise QueryException("Virtual column 'pk__token' may only be compared to Token() values")
                      column = columns._PartitionKeysToken(self.model)
                      quote_field = False
                  else:
                      raise QueryException("Can't resolve column name: '{}'".format(col_name))
  
              if isinstance(val, Token):
                  if col_name != 'pk__token':
                      raise QueryException("Token() values may only be compared to the 'pk__token' virtual column")
                  partition_columns = column.partition_columns
                  if len(partition_columns) != len(val.value):
                      raise QueryException(
                          'Token() received {} arguments but model has {} partition keys'.format(
                              len(val.value), len(partition_columns)))
                  val.set_columns(partition_columns)
  
              #get query operator, or use equals if not supplied
              operator_class = BaseWhereOperator.get_operator(col_op or 'EQ')
              operator = operator_class()
  
              if isinstance(operator, InOperator):
                  if not isinstance(val, (list, tuple)):
                      raise QueryException('IN queries must use a list/tuple value')
                  query_val = [column.to_database(v) for v in val]
              elif isinstance(val, BaseQueryFunction):
                  query_val = val
              else:
                  query_val = column.to_database(val)
  
              clone._where.append(WhereClause(column.db_field_name, operator, query_val, quote_field=quote_field))
  
          return clone