Open
Description
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:
CallBatch/__getattr__/itemcan be marked as type of attributes types ofT(may be a LiteralString)getattrshould have two generic types, one is type of object, the other is type of input name, and change return type when inputnamechanges