I feel -0.5 on this. Do we really want to give users access to handling the backend state via a parameter to rc_context? That feels a bit out of place. Also, passing a user list of excludes is a foot gun because they can easily and unintendedly remove the backend exclusion.

More generally, the need for special-handling backend here (and also in #23263) indicates to ne that we have some design issue here:

I wonder whether we should track the backend state in rcParams at all. RcParams should only hold the defaults, not necessarily actual state. E.g. we store figure.figsize as a default, but the actual value is held by the figure instance. (That‘s not exactly comparable because we can have multiple figures but only one backend state. But say we could only have one figure, then we still would not store its size in rcParams. We shoul consider storing the actual backend in a central place outside of rcParams.

wonder whether we should track the backend state in rcParams at all. RcParams should only hold the defaults, not necessarily actual state. E.g. we store figure.figsize as a default, but the actual value is held by the figure instance.

👍 I don't think we should be storing state in rcParams. We probably could have a rule that nothing can set the rcParams inside the library so the user always has complete control over them.

I also don't think we should expose this API. While I also agree that storing the backend somewhere else than in rcParams may have been better, this may be slightly tricky to change (in particular, you need to keep the ability to set the backend in the matplotlibrc file, and I guess it would be better not to break people using rcParams["backend"] (even though get_backend() has existed as a replacement for a long time too)).

For the specific issue at hand, I think the problem is actually here:

    def __getitem__(self, key):
        if key in _deprecated_map:
            version, alt_key, alt_val, inverse_alt = _deprecated_map[key]
            _api.warn_deprecated(
                version, name=key, obj_type="rcparam", alternative=alt_key)
            return inverse_alt(dict.__getitem__(self, alt_key))

        elif key in _deprecated_ignore_map:
            version, alt_key = _deprecated_ignore_map[key]
            _api.warn_deprecated(
                version, name=key, obj_type="rcparam", alternative=alt_key)
            return dict.__getitem__(self, alt_key) if alt_key else None

        # In theory, this should only ever be used after the global rcParams
        # has been set up, but better be safe e.g. in presence of breakpoints.
        elif key == "backend" and self is globals().get("rcParams"):
            val = dict.__getitem__(self, key)
            if val is rcsetup._auto_backend_sentinel:
                from matplotlib import pyplot as plt
                plt.switch_backend(rcsetup._auto_backend_sentinel)

        return dict.__getitem__(self, key)

    def copy(self):
        rccopy = RcParams()
        for k in self:  # Skip deprecations and revalidation.
            dict.__setitem__(rccopy, k, dict.__getitem__(self, k))
        return rccopy

copy() (which is used by rc_context) uses dict.__getitem__ instead of RcParams.__getitem__ to skip deprecations, but this also skips backend-resolution. Instead, it should use an intermediate version of __getitem__ (_getitem_skipping_deprecations_but_resolving_backend). Now the copy won't see the sentinel. (This means that rc_context will trigger backend resolution, but I think that's actually reasonable: if you enter a rc_context you're about to do some plotting, which will typically need to resolve the backend anyways.)

From the API point of view we want to have

• delayed backend resolution. Ideally only when needed, i.e. not even at the start of the rc_context. But we could maybe bear the resolution at the start of rc_context if we can't get a better solution)
• the end of the rc_conext must not reset the backend
• no additional public API.

Every solution that fulfills this is a viable fix for #23298.

Whether/how we could separate the backend state from rcParams can be discussed separately.

Ah, I guess there's an important point that I missed here: direct assignment to rcParams["backend"] doesn't actually "work" (set the backend) once the backend has already been loaded by pyplot (perhaps this should error?), so I now think that rc_context should just not set that key at all either.

Changed to simply drop the backend key when making the internal copy going with Tim and Antony's suggestion.

I mostly took your suggestion @timhoffm but re-worded it a little bit.

I went with the :rc: markup.