},
                            {
                                "name": "save-data",
                                "in": "header",
                                "required": True,
                                "schema": {"type": "boolean", "title": "Save Data"},
                            },
                            {
                                "name": "if-modified-since",

In fact, in some cases, it will even have **two JSON Schemas** in OpenAPI for the same Pydantic model, for input and output, depending on if they have **default values**.

Let's see how that works and how to change it if you need to do that.

## Pydantic Models for Input and Output { #pydantic-models-for-input-and-output }

Let's say you have a Pydantic model with default values, like this one:

* **Uvicorn**:
    * Will have the best performance, as it doesn't have much extra code apart from the server itself.

must observe a value actually written to that location (perhaps by a concurrent executing goroutine)
and not yet overwritten.
These implementation constraints make Go more like Java or JavaScript,
in that most races have a limited number of outcomes,
and less like C and C++, where the meaning of any program with a race
is entirely undefined, and the compiler may do anything at all.

            assertNotNull(clazz.getMethod("getName"), "Should have getName method");
            assertNotNull(clazz.getMethod("getType"), "Should have getType method");
            assertNotNull(clazz.getMethod("exists"), "Should have exists method");
            assertNotNull(clazz.getMethod("resolve", String.class), "Should have resolve method");
            assertNotNull(clazz.getMethod("close"), "Should have close method");

/// tip

Notice the autocompletion for `name` and `price`, that was defined in the FastAPI application, in the `Item` model.

///

You will have inline errors for the data that you send:

<img src="/img/tutorial/generate-clients/image04.png">

The response object will also have autocompletion:

<img src="/img/tutorial/generate-clients/image05.png">

## FastAPI App with Tags { #fastapi-app-with-tags }

    }

    @Test
    @DisplayName("Should have correct dialect codes for SMB2+ versions")
    void testDialectCodes() {
        // SMB1 should throw UnsupportedOperationException
        assertThrows(UnsupportedOperationException.class, () -> {
            DialectVersion.SMB1.getDialect();
        });

        // SMB2+ versions should have valid dialect codes
        assertTrue(DialectVersion.SMB202.getDialect() > 0);

{* ../../docs_src/dependencies/tutorial008_an_py39.py hl[18:19,26:27] *}

The same way, you could have some dependencies with `yield` and some other dependencies with `return`, and have some of those depend on some of the others.

And you could have a single dependency that requires several other dependencies with `yield`, etc.

You can have any combinations of dependencies that you want.

        // When - Get a buffer
        byte[] buffer = BufferCache.getBuffer();

        // Then - Buffer should have expected size
        assertNotNull(buffer, "Buffer should not be null");
        assertEquals(SmbComTransaction.TRANSACTION_BUF_SIZE, buffer.length, "Buffer should have TRANSACTION_BUF_SIZE");

        // The validation in getBuffer() ensures size is within bounds (0 < size <= 1MB)

	values = expandValues(values)

	if association.Error == nil {
		reflectValue := association.DB.Statement.ReflectValue
		rel := association.Relationship

		var oldBelongsToExpr clause.Expression
		// we have to record the old BelongsTo value
		if association.Unscope && rel.Type == schema.BelongsTo {
			var foreignFields []*schema.Field
			for _, ref := range rel.References {
				if !ref.OwnPrimaryKey {