replicationMaxDataTransferRateMD = NewGaugeMD(replicationMaxDataTransferRate,
		"Maximum replication data transfer rate in bytes/sec seen since server start")
	replicationRecentBacklogCountMD = NewGaugeMD(replicationRecentBacklogCount,
		"Total number of objects seen in replication backlog in the last 5 minutes")
)

// loadClusterReplicationMetrics - `MetricsLoaderFn` for cluster replication metrics

        /*
         * The Filter can only work with NTLMv1 as it uses a man-in-the-middle
         * technique that NTLMv2 specifically thwarts. A real NTLM Filter would
         * need to do a NETLOGON RPC that JCIFS will likely never implement
         * because it requires a lot of extra crypto not used by CIFS.
         */
        p.setProperty("jcifs.smb.lmCompatibility", "0");

    #  The list of table DB names that need to be quoted. Specified tables is quoted on auto-generated SQL.
    #
    #; quoteTableNameList = list:{}
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o quoteColumnNameList: (NotRequired - Default list:{})
    #  The list of column DB names that need to be quoted. Specified columns is quoted on auto-generated SQL.
    #

### Short { #short }

It has sensible **defaults** for everything, with optional configurations everywhere. All the parameters can be fine-tuned to do what you need and to define the API you need.

But by default, it all **"just works"**.

### Validation { #validation }

* Validation for most (or all?) Python **data types**, including:
    * JSON objects (`dict`).

# WebSockets

When defining WebSockets, you normally declare a parameter of type `WebSocket` and with it you can read data from the client and send data to it.

It is provided directly by Starlette, but you can import it from `fastapi`:

```python
from fastapi import WebSocket
```

/// tip

     *
     * @return write operation count
     */
    public long getRdmaWrites() {
        return rdmaWrites.get();
    }

    /**
     * Get total number of RDMA send operations
     *
     * @return send operation count
     */
    public long getRdmaSends() {
        return rdmaSends.get();
    }

    /**
     * Get total number of RDMA receive operations
     *

If you need to enforce it, use `OAuth2PasswordRequestFormStrict` instead of `OAuth2PasswordRequestForm`.

///

* An optional `client_id` (we don't need it for our example).
* An optional `client_secret` (we don't need it for our example).

/// info

        To be awaitable, compatible with async, this is run in threadpool.
        """
        return await super().read(size)

    async def seek(
        self,
        offset: Annotated[
            int,
            Doc(
                """
                The position in bytes to seek to in the file.
                """
            ),
        ],
    ) -> None:
        """
        Move to a position in the file.

like that curious song about the whiting!'

  `Oh, as to the whiting,' said the Mock Turtle, `they--you've
seen them, of course?'

  `Yes,' said Alice, `I've often seen them at dinn--' she
checked herself hastily.

  `I don't know where Dinn may be,' said the Mock Turtle, `but
if you've seen them so often, of course you know what they're
like.'

  `I believe so,' Alice replied thoughtfully.  `They have their

This can be very useful for setting up **resources** that you need to use for the whole app, and that are **shared** among requests, and/or that you need to **clean up** afterwards. For example, a database connection pool, or loading a shared machine learning model.

## Use Case { #use-case }

Let's start with an example **use case** and then see how to solve it with this.