async def METHOD_NAME(idx: int = 0, *ma: Any, **mkw: Any) -> Any:
    middleware: Callable = middlewares[idx]
    logging.bind_logger(
        logger.bind(
            middleware=getattr(middleware, "name", Ellipsis)
            if hasattr(middleware, "name")
            else (
                middleware.__name__
                if hasattr(middleware, "__name__")
                else (
                    type(middleware).__name__
                    if hasattr(type(middleware), "__name__")
                    else str(type(middleware))
                )
            )
        )
    )
    get_contextvar("service.logger").set(logger._context["logger"])
    if getattr(middleware, TOMODACHI_MIDDLEWARE_ATTRIBUTE, None) is None:
        values = inspect.getfullargspec(inspect.unwrap(middleware))
        middleware_kwargs = set(values.args + values.kwonlyargs)
        middleware_args = values.args
        has_defaults = True if values.defaults else False
        has_varargs = True if values.varargs else False
        has_varkw = True if values.varkw else False
        is_bound_method = bool(
            inspect.ismethod(middleware)
            or getattr(middleware, "__self__", None) is middleware
            or inspect.ismethod(getattr(middleware, "__call__", None))
        )
        arg_start = 0 if is_bound_method else 1
        arg_len = len(values.args) - len(values.defaults or ()) + arg_start
        middleware_args_offset = 2 if is_bound_method else 1
        setattr(
            middleware,
            TOMODACHI_MIDDLEWARE_ATTRIBUTE,
            (
                arg_len,
                arg_start,
                middleware_kwargs,
                middleware_args,
                has_defaults,
                has_varargs,
                has_varkw,
                is_bound_method,
                middleware_args_offset,
            ),
        )
    else:
        (
            arg_len,
            arg_start,
            middleware_kwargs,
            middleware_args,
            has_defaults,
            has_varargs,
            has_varkw,
            is_bound_method,
            middleware_args_offset,
        ) = cast(
            Tuple[int, int, Set[str], List[str], bool, bool, bool, bool, int],
            getattr(middleware, TOMODACHI_MIDDLEWARE_ATTRIBUTE),
        )
    if has_varargs and not has_defaults:
        arg_len = 3 + len(args)
    if middlewares and len(middlewares) <= idx + 1:
        @functools.wraps(func)
        async def _func_wrapper(*a: Any, **kw: Any) -> Any:
            return await asyncio.create_task(routine_func(*args, **{**mkw, **kw, **init_kwargs}))
        middleware_arguments = [middleware, _func_wrapper, *args, middleware_context][arg_start:arg_len]
    else:
        @functools.wraps(func)
        async def _middleware_wrapper(*a: Any, **kw: Any) -> Any:
            return await asyncio.create_task(METHOD_NAME(idx + 1, *a, **{**mkw, **kw, **init_kwargs}))
        middleware_arguments = [middleware, _middleware_wrapper, *args, middleware_context][arg_start:arg_len]
    mkw_cleaned = {k: v for k, v in mkw.items() if has_varkw or k in middleware_kwargs}
    for i, key in enumerate(
        middleware_args[middleware_args_offset : len(middleware_arguments)], middleware_args_offset
    ):
        if key in mkw_cleaned:
            middleware_arguments[i] = mkw_cleaned.pop(key)
    if is_bound_method:
        return await asyncio.create_task(middleware(*middleware_arguments[1:], **mkw_cleaned))
    return await asyncio.create_task(middleware(*middleware_arguments, **mkw_cleaned))