code: def _process_comparison_filter_directive(filter_operation_info, location,
                                           context, parameters, operator=None):
      
      comparison_operators = {u'=', u'!=', u'>', u'<', u'>=', u'<='}
      if operator not in comparison_operators:
          raise AssertionError(u'Expected a valid comparison operator ({}), but got '
                               u'{}'.format(comparison_operators, operator))
  
      filtered_field_type = filter_operation_info.field_type
      filtered_field_name = filter_operation_info.field_name
  
      argument_inferred_type = strip_non_null_from_type(filtered_field_type)
      argument_expression, non_existence_expression = _represent_argument(
          location, context, parameters[0], argument_inferred_type)
  
      comparison_expression = expressions.BinaryComposition(
          operator, expressions.LocalField(filtered_field_name), argument_expression)
  
      final_expression = None
      if non_existence_expression is not None:
          # The argument comes from an optional block and might not exist,
          # in which case the filter expression should evaluate to True.
          final_expression = expressions.BinaryComposition(
              u'||', non_existence_expression, comparison_expression)
      else:
          final_expression = comparison_expression
  
      return blocks.Filter(final_expression)
docs: Return a Filter basic block that performs the given comparison against the property field.
  
      Args:
          filter_operation_info: FilterOperationInfo object, containing the directive and field info
                                 of the field where the filter is to be applied.
          location: Location where this filter is used.
          context: dict, various per-compilation data (e.g. declared tags, whether the current block
                   is optional, etc.). May be mutated in-place in this function!
          parameters: list of 1 element, containing the value to perform the comparison against;
                      if the parameter is optional and missing, the check will return True
          operator: unicode, a comparison operator, like '=', '!=', '>=' etc.
                    This is a kwarg only to preserve the same positional arguments in the
                    function signature, to ease validation.
  
      Returns:
          a Filter basic block that performs the requested comparison