utils ¶

def __call__(cls, *args: Any, **kwargs: Any) -> Any:
    if cls in cls._instances and not cls._singleton_init:
        return cls._instances[cls]

    with cls._lock:
        if cls not in cls._instances:
            cls._instances[cls] = obj = super().__call__(*args, **kwargs)
            return obj

        if cls._singleton_init:
            cls._instances[cls].__init__(*args, **kwargs)

    return cls._instances[cls]

@classmethod
def clear_cache(cls, obj: object, names: str | Iterable[str] | None = None) -> None:
    """
    Clear cached properties of an object instance.

    Args:
        obj: The object whose cache should be cleared.
        names: Specific property names to clear. If None, all cached properties are cleared.
    """
    if names is None:
        obj.__dict__.get(cls.cache_key, {}).clear()
        return None

    from ..functions import to_arr

    cache = obj.__dict__.get(cls.cache_key, {})

    for name in to_arr(names):
        with suppress(KeyError):
            del cache[name]

def deleter(self, fdel: Callable[..., None]) -> cachedproperty[_R_co, _T_Any]: ...

def getter(self, fget: Callable[..., _R_co]) -> cachedproperty[_R_co, _T_Any]: ...

def setter(self, fset: Callable[[Any, _T_Any], None]) -> cachedproperty[_R_co, _T_Any]: ...

@classmethod
def update_cache(cls, obj: object, name: str, value: Any) -> None:
    """
    Update cached property of an object instance.

    Args:
        obj: The object whose cache should be updated.
        name: Property name to update.
        value: The value to assign.
    """
    obj.__dict__.setdefault(cls.cache_key, {})[name] = value

def __call__(self_, self: _T_co, *args: _P.args, **kwargs: _P.kwargs) -> _R_co:  # type: ignore[misc]  # noqa: N805
    return self_.__get__(self, type(self))(*args, **kwargs)

@classmethod
def with_name[T0, **P0, R0](
    cls, kwargs_name: str = "kwargs"
) -> Callable[[Callable[Concatenate[T0, P0], R0]], inject_kwargs_params[T0, P0, R0]]:
    """
    Decorator factory that creates a subclass of `inject_kwargs_params` with a custom name
    for the keyword argument store.
    """
    ns = cls.__dict__.copy()
    ns["_kwargs_name"] = kwargs_name

    custom_cls = type(cls.__name__, cls.__bases__, ns)

    # TODO: The precise subclass type cannot be expressed yet when the class is itself generic.
    def _wrapper(function: Callable[Concatenate[T0, P0], R0]) -> inject_kwargs_params[T0, P0, R0]:
        return custom_cls(function)  # pyright: ignore[reportReturnType, reportArgumentType]

    return _wrapper

def __call__(self_, self: _T_co, *args: _P.args, **kwargs: _P.kwargs) -> _R_co:  # type: ignore[misc]  # noqa: N805
    return self_.__get__(self, None)(*args, **kwargs)

@classmethod
def with_args[T0, **P0, R0](
    cls, *args: Any, **kwargs: Any
) -> Callable[[Callable[Concatenate[T0, P0], R0]], inject_self[T0, P0, R0]]:
    """
    Decorator factory to construct an `inject_self` or subclass (`cached`, `init_kwargs`, etc.)
    with specific instantiation arguments.
    """

    # TODO: The precise subclass type cannot be expressed yet when the class is itself generic.
    def _wrapper(function: Callable[Concatenate[T0, P0], R0]) -> inject_self[T0, P0, R0]:
        return cls(function, *args, **kwargs)  # type: ignore[return-value, arg-type]

    return _wrapper