NatsRouter

def __init__(
    self,
    servers: Annotated[
        Union[str, Iterable[str]],
        Doc("NATS cluster addresses to connect."),
    ] = ("nats://localhost:4222",),
    *,
    # connection args
    error_cb: Annotated[
        Optional["ErrorCallback"],
        Doc("Callback to report errors."),
    ] = None,
    disconnected_cb: Annotated[
        Optional["Callback"],
        Doc("Callback to report disconnection from NATS."),
    ] = None,
    closed_cb: Annotated[
        Optional["Callback"],
        Doc("Callback to report when client stops reconnection to NATS."),
    ] = None,
    discovered_server_cb: Annotated[
        Optional["Callback"],
        Doc("Callback to report when a new server joins the cluster."),
    ] = None,
    reconnected_cb: Annotated[
        Optional["Callback"], Doc("Callback to report success reconnection.")
    ] = None,
    name: Annotated[
        Optional[str],
        Doc("Label the connection with name (shown in NATS monitoring)."),
    ] = SERVICE_NAME,
    pedantic: Annotated[
        bool,
        Doc(
            "Turn on NATS server pedantic mode that performs extra checks on the protocol. "
            "https://docs.nats.io/using-nats/developer/connecting/misc#turn-on-pedantic-mode"
        ),
    ] = False,
    verbose: Annotated[
        bool,
        Doc("Verbose mode produce more feedback about code execution."),
    ] = False,
    allow_reconnect: Annotated[
        bool,
        Doc("Whether recover connection automatically or not."),
    ] = True,
    connect_timeout: Annotated[
        int,
        Doc("Timeout in seconds to establish connection with NATS server."),
    ] = DEFAULT_CONNECT_TIMEOUT,
    reconnect_time_wait: Annotated[
        int,
        Doc("Time in seconds to wait for reestablish connection to NATS server"),
    ] = DEFAULT_RECONNECT_TIME_WAIT,
    max_reconnect_attempts: Annotated[
        int,
        Doc("Maximum attempts number to reconnect to NATS server."),
    ] = DEFAULT_MAX_RECONNECT_ATTEMPTS,
    ping_interval: Annotated[
        int,
        Doc("Interval in seconds to ping."),
    ] = DEFAULT_PING_INTERVAL,
    max_outstanding_pings: Annotated[
        int,
        Doc("Maximum number of failed pings"),
    ] = DEFAULT_MAX_OUTSTANDING_PINGS,
    dont_randomize: Annotated[
        bool,
        Doc(
            "Boolean indicating should client randomly shuffle servers list for reconnection randomness."
        ),
    ] = False,
    flusher_queue_size: Annotated[
        int, Doc("Max count of commands awaiting to be flushed to the socket")
    ] = DEFAULT_MAX_FLUSHER_QUEUE_SIZE,
    no_echo: Annotated[
        bool,
        Doc("Boolean indicating should commands be echoed."),
    ] = False,
    tls: Annotated[
        Optional["ssl.SSLContext"],
        Doc("Some SSL context to make NATS connections secure."),
    ] = None,
    tls_hostname: Annotated[
        Optional[str],
        Doc("Hostname for TLS."),
    ] = None,
    user: Annotated[
        Optional[str],
        Doc("Username for NATS auth."),
    ] = None,
    password: Annotated[
        Optional[str],
        Doc("Username password for NATS auth."),
    ] = None,
    token: Annotated[
        Optional[str],
        Doc("Auth token for NATS auth."),
    ] = None,
    drain_timeout: Annotated[
        int,
        Doc("Timeout in seconds to drain subscriptions."),
    ] = DEFAULT_DRAIN_TIMEOUT,
    signature_cb: Annotated[
        Optional["SignatureCallback"],
        Doc(
            "A callback used to sign a nonce from the server while "
            "authenticating with nkeys. The user should sign the nonce and "
            "return the base64 encoded signature."
        ),
    ] = None,
    user_jwt_cb: Annotated[
        Optional["JWTCallback"],
        Doc(
            "A callback used to fetch and return the account "
            "signed JWT for this user."
        ),
    ] = None,
    user_credentials: Annotated[
        Optional["Credentials"],
        Doc("A user credentials file or tuple of files."),
    ] = None,
    nkeys_seed: Annotated[
        Optional[str],
        Doc("Nkeys seed to be used."),
    ] = None,
    inbox_prefix: Annotated[
        Union[str, bytes],
        Doc(
            "Prefix for generating unique inboxes, subjects with that prefix and NUID.ß"
        ),
    ] = DEFAULT_INBOX_PREFIX,
    pending_size: Annotated[
        int,
        Doc("Max size of the pending buffer for publishing commands."),
    ] = DEFAULT_PENDING_SIZE,
    flush_timeout: Annotated[
        Optional[float],
        Doc("Max duration to wait for a forced flush to occur."),
    ] = None,
    # broker args
    graceful_timeout: Annotated[
        Optional[float],
        Doc(
            "Graceful shutdown timeout. Broker waits for all running subscribers completion before shut down."
        ),
    ] = 15.0,
    decoder: Annotated[
        Optional["CustomCallable"],
        Doc("Custom decoder object."),
    ] = None,
    parser: Annotated[
        Optional["CustomCallable"],
        Doc("Custom parser object."),
    ] = None,
    middlewares: Annotated[
        Iterable["BrokerMiddleware[Msg]"],
        Doc("Middlewares to apply to all broker publishers/subscribers."),
    ] = (),
    # AsyncAPI args
    security: Annotated[
        Optional["BaseSecurity"],
        Doc(
            "Security options to connect broker and generate AsyncAPI server security information."
        ),
    ] = None,
    asyncapi_url: Annotated[
        Union[str, Iterable[str], None],
        Doc("AsyncAPI hardcoded server addresses. Use `servers` if not specified."),
    ] = None,
    protocol: Annotated[
        Optional[str],
        Doc("AsyncAPI server protocol."),
    ] = "nats",
    protocol_version: Annotated[
        Optional[str],
        Doc("AsyncAPI server protocol version."),
    ] = "custom",
    description: Annotated[
        Optional[str],
        Doc("AsyncAPI server description."),
    ] = None,
    asyncapi_tags: Annotated[
        Optional[Iterable[Union["asyncapi.Tag", "asyncapi.TagDict"]]],
        Doc("AsyncAPI server tags."),
    ] = None,
    # logging args
    logger: Annotated[
        Optional["LoggerProto"],
        Doc("User specified logger to pass into Context and log service messages."),
    ] = EMPTY,
    log_level: Annotated[
        int,
        Doc("Service messages log level."),
    ] = logging.INFO,
    log_fmt: Annotated[
        Optional[str],
        Doc("Default logger log format."),
    ] = None,
    # StreamRouter options
    setup_state: Annotated[
        bool,
        Doc(
            "Whether to add broker to app scope in lifespan. "
            "You should disable this option at old ASGI servers."
        ),
    ] = True,
    schema_url: Annotated[
        Optional[str],
        Doc(
            "AsyncAPI schema url. You should set this option to `None` to disable AsyncAPI routes at all."
        ),
    ] = "/asyncapi",
    # FastAPI args
    prefix: Annotated[
        str,
        Doc("An optional path prefix for the router."),
    ] = "",
    tags: Annotated[
        Optional[List[Union[str, "Enum"]]],
        Doc(
            """
            A list of tags to be applied to all the *path operations* in this
            router.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.tiangolo.com/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence["params.Depends"]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to all the
            *path and stream operations* in this router.

            Read more about it in the
            [FastAPI docs for Bigger Applications - Multiple Files](https://fastapi.tiangolo.com/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).
            """
        ),
    ] = None,
    default_response_class: Annotated[
        Type["Response"],
        Doc(
            """
            The default response class to be used.

            Read more in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.tiangolo.com/advanced/custom-response/#default-response-class).
            """
        ),
    ] = Default(JSONResponse),
    responses: Annotated[
        Optional[Dict[Union[int, str], "AnyDict"]],
        Doc(
            """
            Additional responses to be shown in OpenAPI.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Additional Responses in OpenAPI](https://fastapi.tiangolo.com/advanced/additional-responses/).

            And in the
            [FastAPI docs for Bigger Applications](https://fastapi.tiangolo.com/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            OpenAPI callbacks that should apply to all *path operations* in this
            router.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.tiangolo.com/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    routes: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            **Note**: you probably shouldn't use this parameter, it is inherited
            from Starlette and supported for compatibility.

            ---

            A list of routes to serve incoming HTTP and WebSocket requests.
            """
        ),
        deprecated(
            """
            You normally wouldn't use this parameter with FastAPI, it is inherited
            from Starlette and supported for compatibility.

            In FastAPI, you normally would use the *path operation methods*,
            like `router.get()`, `router.post()`, etc.
            """
        ),
    ] = None,
    redirect_slashes: Annotated[
        bool,
        Doc(
            """
            Whether to detect and redirect slashes in URLs when the client doesn't
            use the same format.
            """
        ),
    ] = True,
    default: Annotated[
        Optional["ASGIApp"],
        Doc(
            """
            Default function handler for this router. Used to handle
            404 Not Found errors.
            """
        ),
    ] = None,
    dependency_overrides_provider: Annotated[
        Optional[Any],
        Doc(
            """
            Only used internally by FastAPI to handle dependency overrides.

            You shouldn't need to use it. It normally points to the `FastAPI` app
            object.
            """
        ),
    ] = None,
    route_class: Annotated[
        Type["APIRoute"],
        Doc(
            """
            Custom route (*path operation*) class to be used by this router.

            Read more about it in the
            [FastAPI docs for Custom Request and APIRoute class](https://fastapi.tiangolo.com/how-to/custom-request-and-route/#custom-apiroute-class-in-a-router).
            """
        ),
    ] = APIRoute,
    on_startup: Annotated[
        Optional[Sequence[Callable[[], Any]]],
        Doc(
            """
            A list of startup event handler functions.

            You should instead use the `lifespan` handlers.

            Read more in the [FastAPI docs for `lifespan`](https://fastapi.tiangolo.com/advanced/events/).
            """
        ),
    ] = None,
    on_shutdown: Annotated[
        Optional[Sequence[Callable[[], Any]]],
        Doc(
            """
            A list of shutdown event handler functions.

            You should instead use the `lifespan` handlers.

            Read more in the
            [FastAPI docs for `lifespan`](https://fastapi.tiangolo.com/advanced/events/).
            """
        ),
    ] = None,
    lifespan: Annotated[
        Optional["Lifespan[Any]"],
        Doc(
            """
            A `Lifespan` context manager handler. This replaces `startup` and
            `shutdown` functions with a single context manager.

            Read more in the
            [FastAPI docs for `lifespan`](https://fastapi.tiangolo.com/advanced/events/).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark all *path operations* in this router as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.tiangolo.com/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            To include (or not) all the *path operations* in this router in the
            generated OpenAPI.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    generate_unique_id_function: Annotated[
        Callable[["APIRoute"], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.tiangolo.com/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> None:
    super().__init__(
        servers,
        error_cb=error_cb,
        disconnected_cb=disconnected_cb,
        closed_cb=closed_cb,
        discovered_server_cb=discovered_server_cb,
        reconnected_cb=reconnected_cb,
        name=name,
        pedantic=pedantic,
        verbose=verbose,
        allow_reconnect=allow_reconnect,
        connect_timeout=connect_timeout,
        reconnect_time_wait=reconnect_time_wait,
        max_reconnect_attempts=max_reconnect_attempts,
        ping_interval=ping_interval,
        max_outstanding_pings=max_outstanding_pings,
        dont_randomize=dont_randomize,
        flusher_queue_size=flusher_queue_size,
        no_echo=no_echo,
        tls=tls,
        tls_hostname=tls_hostname,
        user=user,
        password=password,
        token=token,
        drain_timeout=drain_timeout,
        signature_cb=signature_cb,
        user_jwt_cb=user_jwt_cb,
        user_credentials=user_credentials,
        nkeys_seed=nkeys_seed,
        inbox_prefix=inbox_prefix,
        pending_size=pending_size,
        flush_timeout=flush_timeout,
        # broker options
        graceful_timeout=graceful_timeout,
        decoder=decoder,
        parser=parser,
        middlewares=middlewares,
        security=security,
        asyncapi_url=asyncapi_url,
        protocol=protocol,
        protocol_version=protocol_version,
        description=description,
        logger=logger,
        log_level=log_level,
        log_fmt=log_fmt,
        asyncapi_tags=asyncapi_tags,
        schema_url=schema_url,
        setup_state=setup_state,
        # FastAPI kwargs
        prefix=prefix,
        tags=tags,
        dependencies=dependencies,
        default_response_class=default_response_class,
        responses=responses,
        callbacks=callbacks,
        routes=routes,
        redirect_slashes=redirect_slashes,
        default=default,
        dependency_overrides_provider=dependency_overrides_provider,
        route_class=route_class,
        on_startup=on_startup,
        on_shutdown=on_shutdown,
        deprecated=deprecated,
        include_in_schema=include_in_schema,
        lifespan=lifespan,
        generate_unique_id_function=generate_unique_id_function,
    )