BaseMiddleware

async def after_consume(self, err: Optional[Exception]) -> None:
    """A function to handle the result of consuming a resource asynchronously.

    Args:
        err : Optional exception that occurred during consumption

    Raises:
        err : If an exception occurred during consumption
    """
    if err is not None:
        raise err

async def after_processed(
    self,
    exc_type: Optional[Type[BaseException]] = None,
    exc_val: Optional[BaseException] = None,
    exec_tb: Optional[TracebackType] = None,
) -> Optional[bool]:
    """Asynchronously called after processing.

    Args:
        exc_type: Optional exception type
        exc_val: Optional exception value
        exec_tb: Optional traceback

    Returns:
        Optional boolean value indicating whether the processing was successful or not.
    """
    return False

async def after_publish(self, err: Optional[Exception]) -> None:
    """Asynchronous function to handle the after publish event.

    Args:
        err: Optional exception that occurred during the publish

    Returns:
        None

    Raises:
        Exception: If an error occurred during the publish
    """
    if err is not None:
        raise err

@asynccontextmanager
async def consume_scope(self, msg: DecodedMessage) -> AsyncIterator[DecodedMessage]:
    """Asynchronously consumes a message and returns an asynchronous iterator of decoded messages.

    Args:
        msg: The decoded message to consume.

    Yields:
        An asynchronous iterator of decoded messages.

    Returns:
        An asynchronous iterator of decoded messages.

    Raises:
        Exception: If an error occurs while consuming the message.

    AsyncIterator:
        An asynchronous iterator that yields decoded messages.

    Note:
        This function is an async function.
    """
    err: Optional[Exception]
    try:
        yield await self.on_consume(msg)
    except Exception as e:
        err = e
    else:
        err = None
    await self.after_consume(err)

async def on_consume(self, msg: DecodedMessage) -> DecodedMessage:
    """Asynchronously consumes a message.

    Args:
        msg: The message to be consumed.

    Returns:
        The consumed message.
    """
    return msg

async def on_publish(self, msg: SendableMessage) -> SendableMessage:
    """Asynchronously handle a publish event.

    Args:
        msg: The message to be published.

    Returns:
        The published message.
    """
    return msg

async def on_receive(self) -> None:
    pass

@asynccontextmanager
async def publish_scope(
    self, msg: SendableMessage
) -> AsyncIterator[SendableMessage]:
    """Publish a message and return an async iterator.

    Args:
        msg: The message to be published.

    Yields:
        A sendable message.

    Returns:
        An async iterator of sendable messages.

    Raises:
        Exception: If an error occurs during publishing.

    """
    err: Optional[Exception]
    try:
        yield await self.on_publish(msg)
    except Exception as e:
        err = e
    else:
        err = None
    await self.after_publish(err)