if not cname:
    c = logging.Formatter
else:
    c = _resolve(cname)  # this might actually resolve to logging.Formatter

if c is logging.Formatter:
    # we know c will accept the validate parameter
    use_validate = True
    validate = config.get('validate', True)
else:
    # we don't yet know if c will accept a validate parameter.
    use_validate = False
    # Here, we could go to some trouble to determine whether there's a validate
    # or kwargs parameter, as you've done. But we have to take care:  there are
    # a number of things to consider. We currently call c with fmt, dfmt, style
    # arguments. So we expect c to be a class which inherits from
    # logging.Formatter and either doesn't redefine __init__, or does redefine
    # it. In the first case, we'd be safe to set use_validate to True, but in
    # the second, we wouldn't, because we don't know if this a Formatter
    # subclass written after 3.8 was released - when the developer of it would
    # be expected to know about the validate parameter - or whether it was a
    # class designed before 3.8, when they wouldn't be expected to know about
    # it. If it's specified in the config, then they know about it and we can
    # assume it's a post-3.8 design, so we can pass the configured value;
    # otherwise, we have as yet no idea if the redefined __init__ will accept
    # validate. We could dig into its signature to see if we could figure it
    # out, but there's no guarantee it will be *our* validate parameter - even
    # if we can figure out that it's expected to be a bool, we have no idea
    # how a True value would be interpreted. So it's safest not to pass it.

    # In the case that c is a class which doesn't even inherit from Formatter,
    # we have no idea what its __init__ does, though we do know that it has to
    # take (fmt, dfmt, style) parameters, otherwise it wouldn't work now.
    # Thus:

    if issubclass(c, logging.Formatter):
        if '__init__' not in c.__dict__:  # not redefined
            use_validate = True
        elif 'validate' in config:  # user has specified it, so OK to use
            use_validate = True
        # else:
            # if we decided to implement signature checking, we would import
            # inspect here and introspect the signature. Note that you couldn't
            # rely on a parameter literally named 'kwargs' - someone could have
            # used **kw, for example. You'd have to rely on there being a
            # specific parameter p such that p.kind == inspect._VAR_KEYWORD.

if use_validate :
    result = c(fmt, dfmt, style)
else:
    result = c(fmt, dfmt, style, validate)