StreamRoute

def __init__(
    self,
    path: Union[NameRequired, str, None],
    *extra: Union[NameRequired, str],
    endpoint: Union[
        Callable[P_HandlerParams, T_HandlerReturn],
        HandlerCallWrapper[MsgType, P_HandlerParams, T_HandlerReturn],
    ],
    broker: BrokerAsyncUsecase[MsgType, Any],
    dependencies: Sequence[params.Depends],
    provider_factory: Callable[[], Any],
    **handle_kwargs: Any,
) -> None:
    """Initialize a class instance.

    Args:
        path: The path of the instance.
        *extra: Additional arguments.
        endpoint: The endpoint of the instance.
        broker: The broker of the instance.
        dependencies: The dependencies of the instance.
        provider_factory: Provider factory for dependency overrides.
        **handle_kwargs: Additional keyword arguments.

    Returns:
        None.
    """
    self.path = path or ""
    self.broker = broker

    path_name = self.path if isinstance(self.path, str) else self.path.name

    if isinstance(endpoint, HandlerCallWrapper):
        orig_call = endpoint._original_call
    else:
        orig_call = endpoint

    dependant = get_dependant(
        path=path_name,
        call=orig_call,
    )
    for depends in dependencies[::-1]:
        dependant.dependencies.insert(
            0,
            get_parameterless_sub_dependant(depends=depends, path=path_name),
        )
    self.dependant = dependant

    call = wraps(orig_call)(
        StreamMessage.get_session(
            dependant,
            provider_factory,
        )
    )

    if isinstance(endpoint, HandlerCallWrapper):
        endpoint._original_call = call
        handler = endpoint

    else:
        handler = call

    self.handler = broker.subscriber(
        *extra,
        _raw=True,
        _get_dependant=lambda call: dependant,
        **handle_kwargs,
    )(
        handler  # type: ignore[arg-type]
    )