code: def _normalise_key_values(filter_obj, attr_map=None):
      
      new_filter = {}
      for key, constraints in filter_obj.items():
          aliased_key = key
          if attr_map is not None:
              aliased_key = attr_map.get(key)
              if aliased_key is None:
                  raise CloudValueError(
                      'Invalid key %r for filter attribute; must be one of:\n%s' % (
                          key,
                          attr_map.keys()
                      )
                  )
          if not isinstance(constraints, dict):
              constraints = {'eq': constraints}
          for operator, value in constraints.items():
              # FIXME: deprecate this $ nonsense
              canonical_operator = FILTER_OPERATOR_ALIASES.get(operator.lstrip('$'))
              if canonical_operator is None:
                  raise CloudValueError(
                      'Invalid operator %r for filter key %s; must be one of:\n%s' % (
                          operator,
                          key,
                          FILTER_OPERATOR_ALIASES.keys()
                      )
                  )
              canonical_key = str('%s__%s' % (aliased_key, canonical_operator))
              new_filter[canonical_key] = _normalise_value(value)
      return new_filter
docs: Converts nested dictionary filters into django-style key value pairs
  
      Map filter operators and aliases to operator-land
      Additionally, perform replacements according to attribute map
      Automatically assumes __eq if not explicitly defined