import okio.buffer
import okio.source
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ArgumentsSource

/** Runs the web platform URL tests against Java URL models.  */
class WebPlatformUrlTest {
  class TestDataParamProvider : SimpleProvider() {
    override fun arguments() = ArrayList<Any>(loadTests())
  }

  /** Test how [HttpUrl] does against the web platform test suite.  */

* 🌐 Add Korean translation for `docs/ko/docs/tutorial/header-param-models.md`. PR [#13001](https://github.com/fastapi/fastapi/pull/13001) by [@hard-coders](https://github.com/hard-coders).

### Security and authentication { #security-and-authentication }

Security and authentication integrated. Without any compromise with databases or data models.

All the security schemes defined in OpenAPI, including:

* HTTP Basic.
* **OAuth2** (also with **JWT tokens**). Check the tutorial on [OAuth2 with JWT](tutorial/security/oauth2-jwt.md).
* API keys in:

  },
  {
    "name": "kotlin-dsl-tooling-model-impls",
    "path": "platforms/core-configuration/kotlin-dsl-tooling-model-impls",
    "unitTests": false,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "kotlin-dsl-tooling-models",
    "path": "platforms/core-configuration/kotlin-dsl-tooling-models",
    "unitTests": false,
    "functionalTests": false,

    *   `Model.fit_generator`, `Model.evaluate_generator`,
        `Model.predict_generator`, `Model.train_on_batch`,
        `Model.test_on_batch`, and `Model.predict_on_batch` methods now respect
        the `run_eagerly` property, and will correctly run using `tf.function`
        by default. Note that `Model.fit_generator`, `Model.evaluate_generator`,

If you want to secure your API, there are several better things you can do, for example:

* Make sure you have well defined Pydantic models for your request bodies and responses.
* Configure any required permissions and roles using dependencies.
* Never store plaintext passwords, only password hashes.

platforms/core-configuration/kotlin-dsl-provider-plugins/   @gradle/bt-tide
platforms/core-configuration/kotlin-dsl-tooling-builders/   @gradle/bt-tide
platforms/core-configuration/kotlin-dsl-tooling-models/     @gradle/bt-tide

# Core automation platform (Declarative DSL)
platforms/core-configuration/declarative-dsl-api/                   @gradle/bt-declarative-gradle-project

/**
 * A test which demonstrates maven's recursive inheritance where
 * a distinct value is taken from each parent contributing to
 * the final model of the project being assembled. There is no
 * overriding going on amongst the models being used in this test:
 * each model in the lineage is providing a value that is not present
 * anywhere else in the lineage. We are just making sure that values

///

## Embed a single body parameter { #embed-a-single-body-parameter }

Let's say you only have a single `item` body parameter from a Pydantic model `Item`.

By default, **FastAPI** will then expect its body directly.

But if you want it to expect a JSON with a key `item` and inside of it the model contents, as it does when you declare extra body parameters, you can use the special `Body` parameter `embed`:

```Python

<img src="/img/python-types/image06.png">

Notice that this means "`one_person` is an **instance** of the class `Person`".

It doesn't mean "`one_person` is the **class** called `Person`".

## Pydantic models { #pydantic-models }

[Pydantic](https://docs.pydantic.dev/) is a Python library to perform data validation.

You declare the "shape" of the data as classes with attributes.

And each attribute has a type.