Making a dictionary covariant, or some other way to type an old pattern

[DanielNoord]

I know you can't make a dictionary covariant and it's probably impossible to type the following pattern correctly but I thought it wouldn't hurt to ask.
We have the following simplified pattern:

from __future__ import annotations

from collections import defaultdict
from collections.abc import Callable
from typing import Type, TypeVar

_T = TypeVar("_T", bound="Parent")

_FunctionPairDict = defaultdict[Type[_T], list[Callable[[_T], str]]]


class Parent:
    ...


class Child(Parent):
    ...


class MyClass:
    def __init__(self) -> None:
        self.function_pairs: _FunctionPairDict[Parent] = defaultdict(list)

    def add_function(self, node: Parent, func_1: Callable[[Parent], str]) -> None:
        self.function_pairs[node.__class__].append(func_1)

    def add_function_2(self, node: Parent, func_1: Callable[[Child], str]) -> None:
        self.function_pairs[node.__class__].append(func_1)

    def add_function_3(self, node: Child, func_1: Callable[[Child], str]) -> None:
        self.function_pairs[node.__class__].append(func_1)

Basically, I want add_function_2 to produce an error. In layman terms the function_pairs dictionary should behave as follows:
Store a key-value pair for every type of the subclasses of Parent where every value is a list of functions that only accept an instance of the type of the key.

Can you type this in Python? Or this code so un-typesafe that it is not expressible?