docs: def certify_dict_schema(
      value, schema=None, key_certifier=None, value_certifier=None, required=None, allow_extra=None,
  ):
      """
      Certify the dictionary schema.
  
      :param dict|Mapping|MutableMapping value:
          The mapping value to certify against the schema.
      :param object schema:
          The schema to validate with.
      :param callable key_certifier:
          A certifier to use on the dictionary's keys.
      :param callable value_certifier:
          A certifier to use on the dictionary's values.
      :param bool required:
          Whether the value can't be `None`. Defaults to True.
      :param bool allow_extra:
          Set to `True` to ignore extra keys.
      :return:
          The certified mapping
      :rtype:
          dict|Mapping|MutableMapping
      """
      if key_certifier is not None or value_certifier is not None:
          for key, val in value.items():
              if key_certifier is not None:
                  key_certifier(key)
              if value_certifier is not None:
                  value_certifier(val)
  
      if schema:
          if not isinstance(schema, dict):
              raise CertifierParamError(
                  name='schema',
                  value=schema,
              )
  
          for key, certifier in schema.items():
              if key not in value:
                  raise CertifierValueError(
                      message="key \'{key}\' missing from dictionary".format(
                          key=key),
                      required=required,
                  )
              val = value[key]
              certifier(value=val)
  
          if not allow_extra and set(schema) != set(value):
              values = set(value) - set(schema)
              raise CertifierValueError(
                  message="encountered unexpected keys: {unexpected!r}".format(
                      unexpected=values),
                  value=values,
                  required=required,
              )