code: def process_filter_args(cls, kwargs):
      
  
      output = {}
  
      for key, value in kwargs.items():
          if '__' in key:
              prop, operator = key.rsplit('__')
              operator = OPERATOR_TABLE[operator]
          else:
              prop = key
              operator = '='
  
          if prop not in cls.defined_properties(rels=False):
              raise ValueError("No such property {0} on {1}".format(prop, cls.__name__))
  
          property_obj = getattr(cls, prop)
          if isinstance(property_obj, AliasProperty):
              prop = property_obj.aliased_to()
              deflated_value = getattr(cls, prop).deflate(value)
          else:
              # handle special operators
              if operator == _SPECIAL_OPERATOR_IN:
                  if not isinstance(value, tuple) and not isinstance(value, list):
                      raise ValueError('Value must be a tuple or list for IN operation {0}={1}'.format(key, value))
                  deflated_value = [property_obj.deflate(v) for v in value]
              elif operator == _SPECIAL_OPERATOR_ISNULL:
                  if not isinstance(value, bool):
                      raise ValueError('Value must be a bool for isnull operation on {0}'.format(key))
                  operator = 'IS NULL' if value else 'IS NOT NULL'
                  deflated_value = None
              elif operator in _REGEX_OPERATOR_TABLE.values():
                  deflated_value = property_obj.deflate(value)
                  if not isinstance(deflated_value, basestring):
                      raise ValueError('Must be a string value for {0}'.format(key))
                  if operator in _STRING_REGEX_OPERATOR_TABLE.values():
                      deflated_value = re.escape(deflated_value)
                  deflated_value = operator.format(deflated_value)
                  operator = _SPECIAL_OPERATOR_REGEX
              else:
                  deflated_value = property_obj.deflate(value)
  
          # map property to correct property name in the database
          db_property = cls.defined_properties(rels=False)[prop].db_property or prop
  
          output[db_property] = (operator, deflated_value)
  
      return output
docs: loop through properties in filter parameters check they match class definition
      deflate them and convert into something easy to generate cypher from