AsyncAPIStreamSubscriber

@override
def setup(  # type: ignore[override]
    self,
    *,
    connection: Optional["Redis[bytes]"],
    # basic args
    logger: Optional["LoggerProto"],
    producer: Optional["ProducerProto"],
    graceful_timeout: Optional[float],
    extra_context: "AnyDict",
    # broker options
    broker_parser: Optional["CustomCallable"],
    broker_decoder: Optional["CustomCallable"],
    # dependant args
    apply_types: bool,
    is_validate: bool,
    _get_dependant: Optional[Callable[..., Any]],
    _call_decorators: Iterable["Decorator"],
) -> None:
    self._client = connection

    super().setup(
        logger=logger,
        producer=producer,
        graceful_timeout=graceful_timeout,
        extra_context=extra_context,
        broker_parser=broker_parser,
        broker_decoder=broker_decoder,
        apply_types=apply_types,
        is_validate=is_validate,
        _get_dependant=_get_dependant,
        _call_decorators=_call_decorators,
    )

def add_prefix(self, prefix: str) -> None:
    new_stream = deepcopy(self.stream_sub)
    new_stream.name = "".join((prefix, new_stream.name))
    self.stream_sub = new_stream

def schema(self) -> Dict[str, Channel]:
    """Returns the schema of the API operation as a dictionary of channel names and channel objects."""
    if self.include_in_schema:
        return self.get_schema()
    else:
        return {}

def add_middleware(self, middleware: "BrokerMiddleware[MsgType]") -> None:
    self._broker_middlewares = (*self._broker_middlewares, middleware)

def get_log_context(
    self,
    message: Optional["BrokerStreamMessage[Any]"],
) -> Dict[str, str]:
    return self.build_log_context(
        message=message,
        channel=self.stream_sub.name,
    )

@override
async def start(self) -> None:
    if self.task:
        return

    assert self._client, "You should setup subscriber at first."  # nosec B101

    client = self._client

    self.extra_watcher_options.update(
        redis=client,
        group=self.stream_sub.group,
    )

    stream = self.stream_sub

    read: Callable[
        [str],
        Awaitable[
            Tuple[
                Tuple[
                    TopicName,
                    Tuple[
                        Tuple[
                            Offset,
                            Dict[bytes, bytes],
                        ],
                        ...,
                    ],
                ],
                ...,
            ],
        ],
    ]

    if stream.group and stream.consumer:
        try:
            await client.xgroup_create(
                name=stream.name,
                id=self.last_id,
                groupname=stream.group,
                mkstream=True,
            )
        except ResponseError as e:
            if "already exists" not in str(e):
                raise e

        def read(
            _: str,
        ) -> Awaitable[
            Tuple[
                Tuple[
                    TopicName,
                    Tuple[
                        Tuple[
                            Offset,
                            Dict[bytes, bytes],
                        ],
                        ...,
                    ],
                ],
                ...,
            ],
        ]:
            return client.xreadgroup(
                groupname=stream.group,
                consumername=stream.consumer,
                streams={stream.name: ">"},
                count=stream.max_records,
                block=stream.polling_interval,
                noack=stream.no_ack,
            )

    else:

        def read(
            last_id: str,
        ) -> Awaitable[
            Tuple[
                Tuple[
                    TopicName,
                    Tuple[
                        Tuple[
                            Offset,
                            Dict[bytes, bytes],
                        ],
                        ...,
                    ],
                ],
                ...,
            ],
        ]:
            return client.xread(
                {stream.name: last_id},
                block=stream.polling_interval,
                count=stream.max_records,
            )

    await super().start(read)

async def close(self) -> None:
    await super().close()

    if self.task is not None and not self.task.done():
        self.task.cancel()
    self.task = None

async def consume(self, msg: MsgType) -> Any:
    """Consume a message asynchronously."""
    if not self.running:
        return None

    try:
        return await self.process_message(msg)

    except StopConsume:
        # Stop handler at StopConsume exception
        await self.close()

    except SystemExit:
        # Stop handler at `exit()` call
        await self.close()

        if app := context.get("app"):
            app.exit()

    except Exception:  # nosec B110
        # All other exceptions were logged by CriticalLogMiddleware
        pass

async def process_message(self, msg: MsgType) -> "Response":
    """Execute all message processing stages."""
    async with AsyncExitStack() as stack:
        stack.enter_context(self.lock)

        # Enter context before middlewares
        for k, v in self.extra_context.items():
            stack.enter_context(context.scope(k, v))

        stack.enter_context(context.scope("handler_", self))

        # enter all middlewares
        middlewares: List[BaseMiddleware] = []
        for base_m in self._broker_middlewares:
            middleware = base_m(msg)
            middlewares.append(middleware)
            await middleware.__aenter__()

        cache: Dict[Any, Any] = {}
        parsing_error: Optional[Exception] = None
        for h in self.calls:
            try:
                message = await h.is_suitable(msg, cache)
            except Exception as e:
                parsing_error = e
                break

            if message is not None:
                # Acknowledgement scope
                # TODO: move it to scope enter at `retry` option deprecation
                await stack.enter_async_context(
                    self.watcher(
                        message,
                        **self.extra_watcher_options,
                    )
                )

                stack.enter_context(
                    context.scope("log_context", self.get_log_context(message))
                )
                stack.enter_context(context.scope("message", message))

                # Middlewares should be exited before scope release
                for m in middlewares:
                    stack.push_async_exit(m.__aexit__)

                result_msg = ensure_response(
                    await h.call(
                        message=message,
                        # consumer middlewares
                        _extra_middlewares=(
                            m.consume_scope for m in middlewares[::-1]
                        ),
                    )
                )

                if not result_msg.correlation_id:
                    result_msg.correlation_id = message.correlation_id

                for p in chain(
                    self.__get_response_publisher(message),
                    h.handler._publishers,
                ):
                    await p.publish(
                        result_msg.body,
                        **result_msg.as_publish_kwargs(),
                        # publisher middlewares
                        _extra_middlewares=[
                            m.publish_scope for m in middlewares[::-1]
                        ],
                    )

                # Return data for tests
                return result_msg

        # Suitable handler was not found or
        # parsing/decoding exception occurred
        for m in middlewares:
            stack.push_async_exit(m.__aexit__)

        if parsing_error:
            raise parsing_error

        else:
            raise SubscriberNotFound(f"There is no suitable handler for {msg=}")

    # An error was raised and processed by some middleware
    return ensure_response(None)

@override
async def get_one(  # type: ignore[override]
    self,
    *,
    timeout: float = 5.0,
) -> "Optional[RedisStreamMessage]":
    assert self._client, "You should start subscriber at first."  # nosec B101
    assert (  # nosec B101
        not self.calls
    ), "You can't use `get_one` method if subscriber has registered handlers."

    stream_message = await self._client.xread(
        {self.stream_sub.name: self.last_id},
        block=math.ceil(timeout * 1000),
        count=1,
    )

    if not stream_message:
        return None

    ((stream_name, ((message_id, raw_message),)),) = stream_message

    self.last_id = message_id.decode()

    msg: RedisStreamMessage = await process_msg(  # type: ignore[assignment]
        msg=DefaultStreamMessage(
            type="stream",
            channel=stream_name.decode(),
            message_ids=[message_id],
            data=raw_message,
        ),
        middlewares=self._broker_middlewares,  # type: ignore[arg-type]
        parser=self._parser,
        decoder=self._decoder,
    )
    return msg

def add_call(
    self,
    *,
    filter_: "Filter[Any]",
    parser_: Optional["CustomCallable"],
    decoder_: Optional["CustomCallable"],
    middlewares_: Sequence["SubscriberMiddleware[Any]"],
    dependencies_: Iterable["Depends"],
) -> Self:
    self._call_options = _CallOptions(
        filter=filter_,
        parser=parser_,
        decoder=decoder_,
        middlewares=middlewares_,
        dependencies=dependencies_,
    )
    return self

def get_name(self) -> str:
    return f"{self.stream_sub.name}:{self.call_name}"

def get_description(self) -> Optional[str]:
    """Returns the description of the handler."""
    if not self.calls:  # pragma: no cover
        return None

    else:
        return self.calls[0].description

def get_schema(self) -> Dict[str, Channel]:
    payloads = self.get_payloads()

    return {
        self.name: Channel(
            description=self.description,
            subscribe=Operation(
                message=Message(
                    title=f"{self.name}:Message",
                    payload=resolve_payloads(payloads),
                    correlationId=CorrelationId(
                        location="$message.header#/correlation_id"
                    ),
                ),
            ),
            bindings=ChannelBinding(
                redis=self.channel_binding,
            ),
        )
    }

def get_payloads(self) -> List[Tuple["AnyDict", str]]:
    """Get the payloads of the handler."""
    payloads: List[Tuple[AnyDict, str]] = []

    for h in self.calls:
        if h.dependant is None:
            raise SetupError("You should setup `Handler` at first.")

        body = parse_handler_params(
            h.dependant,
            prefix=f"{self.title_ or self.call_name}:Message",
        )

        payloads.append((body, to_camelcase(h.call_name)))

    if not self.calls:
        payloads.append(
            (
                {
                    "title": f"{self.title_ or self.call_name}:Message:Payload",
                },
                to_camelcase(self.call_name),
            )
        )

    return payloads

@staticmethod
def build_log_context(
    message: Optional["BrokerStreamMessage[Any]"],
    channel: str = "",
) -> Dict[str, str]:
    return {
        "channel": channel,
        "message_id": getattr(message, "message_id", ""),
    }