<!--              <exclude>org.apache.maven.model.inheritance.DefaultInheritanceAssembler</exclude>-->

import javax.inject.Singleton;

import org.apache.maven.model.Build;
import org.apache.maven.model.Model;

/**
 * DefaultModelInheritanceAssembler
 */
@Named
@Singleton
@Deprecated
public class DefaultModelInheritanceAssembler implements ModelInheritanceAssembler {
    @Override
    public void assembleModelInheritance(Model child, Model parent, String childPathAdjustment) {

When you create a **FastAPI** *path operation* you can normally return any data from it: a `dict`, a `list`, a Pydantic model, a database model, etc.

If you declare a [Response Model](../tutorial/response-model.md) FastAPI will use it to serialize the data to JSON, using Pydantic.

If you don't declare a response model, FastAPI will use the `jsonable_encoder` explained in [JSON Compatible Encoder](../tutorial/encoder.md) and put it in a `JSONResponse`.

# Header Parameter Models { #header-parameter-models }

If you have a group of related **header parameters**, you can create a **Pydantic model** to declare them.

This would allow you to **re-use the model** in **multiple places** and also to declare validations and metadata for all the parameters at once. 😎

/// note

This is supported since FastAPI version `0.115.0`. 🤓

///

class HeaderModelOptionalListStr(BaseModel):
    p: list[str] | None = None


@app.get("/model-optional-list-str")
async def read_model_optional_list_str(
    p: Annotated[HeaderModelOptionalListStr, Header()],
):
    return {"p": p.p}


@pytest.mark.parametrize(
    "path",
    ["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_schema(path: str):

/**
 * Unit tests for the {@link ModelVersionUtils} utility class.
 * Tests model version detection, validation, upgrade logic, and namespace operations.
 */
@DisplayName("ModelVersionUtils")
class ModelVersionUtilsTest {

    @Nested
    @DisplayName("Model Version Detection")
    class ModelVersionDetectionTests {

        @Test
        @DisplayName("should detect model version from document")

import common.Os
import common.buildScanTagParam
import common.getBuildScanCustomValueParam
import common.setArtifactRules
import model.CIBuildModel
import model.Stage

class CompileAll(
    model: CIBuildModel,
    stage: Stage,
) : OsAwareBaseGradleBuildType(os = Os.LINUX, stage = stage, init = {
        id(buildTypeId(model))
        name = "Compile All"
        description = "Compiles all production/test source code and warms up the build cache"

Here we are simulating the expensive *startup* operation of loading the model by putting the (fake) model function in the dictionary with machine learning models before the `yield`. This code will be executed **before** the application **starts taking requests**, during the *startup*.

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.model.merge;

import java.util.Arrays;

import org.apache.maven.api.model.Contributor;
import org.apache.maven.api.model.Dependency;
import org.apache.maven.api.model.Model;
import org.apache.maven.model.v4.MavenMerger;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

    data = {"items": [["foo", "bar"], ["baz", "whatelse"]]}
    response = client.post("/model-with-tuple/", json=data)
    assert response.status_code == 200, response.text
    assert response.json() == data


def test_model_with_tuple_invalid():
    data = {"items": [["foo", "bar"], ["baz", "whatelse", "too", "much"]]}
    response = client.post("/model-with-tuple/", json=data)
    assert response.status_code == 422, response.text