docs: def specific_error(error):
      """Try to find the best error for humans to resolve
  
      The jsonschema.exceptions.best_match error is based purely on a
      mix of a strong match (ie. not anyOf, oneOf) and schema depth,
      this often yields odd results that are semantically confusing,
      instead we can use a bit of structural knowledge of schema to
      provide better results.
      """
      if error.validator not in ('anyOf', 'oneOf'):
          return error
  
      r = t = None
  
      if isinstance(error.instance, dict):
          t = error.instance.get('type')
          r = error.instance.get('resource')
  
      if r is not None:
          found = None
          for idx, v in enumerate(error.validator_value):
              if v['$ref'].rsplit('/', 2)[1].endswith(r):
                  found = idx
                  break
          if found is not None:
              # error context is a flat list of all validation
              # failures, we have to index back to the policy
              # of interest.
              for e in error.context:
                  # resource policies have a fixed path from
                  # the top of the schema
                  if e.absolute_schema_path[4] == found:
                      return specific_error(e)
              return specific_error(error.context[idx])
  
      if t is not None:
          found = None
          for idx, v in enumerate(error.validator_value):
              if '$ref' in v and v['$ref'].rsplit('/', 2)[-1] == t:
                  found = idx
                  break
              elif 'type' in v and t in v['properties']['type']['enum']:
                  found = idx
                  break
  
          if found is not None:
              for e in error.context:
                  for el in reversed(e.absolute_schema_path):
                      if isinstance(el, int):
                          if el == found:
                              return e
                          break
      return error