Need type hint for `getattr`

from __future__ import annotations

from typing import Callable, Generator, LiteralString, Self, Tuple


class Callbacks[**P, T]:
    def __init__(self, funcs: Generator[Callable[P, T]]):
        self.funcs = funcs

    def __call__(self, *args: P.args, **kwargs: P.kwargs):
        return [func(*args, **kwargs) for func in self.funcs]


class CallBatch[T]:
    def __init__(self, objs: Generator[T]):
        self.objs = objs

    def __getattr__[ITEM:LiteralString](self, item:ITEM):
        return Callbacks(getattr(obj, item) for obj in self.objs)


class A:
    instances_pool = dict[str, Self]()

    @classmethod
    def get(cls, x: str, y: int):
        id = cls.get_id(x, y)
        if id in cls.instances_pool:
            return cls.instances_pool[id]
        return cls(x, y)

    @classmethod
    def get_id(cls, x: str, y: int):
        return f"{x}_{y}"

    @classmethod
    def call_batch(cls, *xy: Tuple[str, int]):
        return CallBatch[Self](cls.get(x, y) for x, y in xy)

    def __init__(self, x: str, y: int):
        self.x = x
        self.y = y
        self.id = self.get_id(x, y)
        self.instances_pool[self.id] = self

    def get_x(self):
        return self.x

    def get_y(self):
        return self.y


x = A.call_batch(("1", 1), ("2", 2)).get_x()
x = A.call_batch(("1", 1), ("2", 2)).get_y()

I want type inference for Callbacks.
To achieve this, abilities blow should be support:

1. CallBatch/__getattr__/item can be marked as type of attributes types of T(may be a LiteralString)
2. getattr should have two generic types, one is type of object, the other is type of input name, and change return type when input name changes

Start with the supplied CallBatch and Callbacks example, focusing on CallBatch.getattr and the requested generic getattr behavior. Done means the get_x and get_y calls demonstrate inferred callback types that vary with the accessed attribute name, as described in the issue.