{* ../../docs_src/body/tutorial002_py310.py *}

## Requestbody- + Pfad-Parameter { #request-body-path-parameters }

Sie können Pfad-Parameter und den Requestbody gleichzeitig deklarieren.

**FastAPI** erkennt, dass Funktionsparameter, die mit Pfad-Parametern übereinstimmen, **vom Pfad genommen** werden sollen, und dass Funktionsparameter, welche Pydantic-Modelle sind, **vom Requestbody genommen** werden sollen.

                    },
                    "post": {
                        "summary": "Create Item",
                        "operationId": "create_item_items__post",
                        "requestBody": {
                            "content": {
                                "application/json": {
                                    "schema": {

 * limitations under the License.
 */
package okhttp3.internal.http

import okhttp3.RequestBody
import okio.BufferedSink
import okio.GzipSink
import okio.buffer

internal class GzipRequestBody(
  val delegate: RequestBody,
) : RequestBody() {
  override fun contentType() = delegate.contentType()

  // We don't know the compressed length in advance!

    return true
  }

  private fun requestIsOneShot(
    e: IOException,
    userRequest: Request,
  ): Boolean {
    val requestBody = userRequest.body
    return (requestBody != null && requestBody.isOneShot()) ||
      e is FileNotFoundException
  }

  private fun isRecoverable(
    e: IOException,
    requestSendStarted: Boolean,
  ): Boolean {

    open fun head(): Builder = method("HEAD", null)

    open fun post(body: RequestBody): Builder = method("POST", body)

    @JvmOverloads
    open fun delete(body: RequestBody? = RequestBody.EMPTY): Builder = method("DELETE", body)

    open fun put(body: RequestBody): Builder = method("PUT", body)

    open fun patch(body: RequestBody): Builder = method("PATCH", body)

    /**

      level = DeprecationLevel.ERROR,
    )
    fun body(): RequestBody = body

    companion object {
      @JvmStatic
      fun create(body: RequestBody): Part = create(null, body)

      @JvmStatic
      fun create(
        headers: Headers?,
        body: RequestBody,
      ): Part {
        require(headers?.get("Content-Type") == null) { "Unexpected header: Content-Type" }

          = MediaType.parse("text/x-markdown; charset=utf-8");

      private final OkHttpClient client = new OkHttpClient();

      public void run() throws Exception {
        RequestBody requestBody = new RequestBody() {
          @Override public MediaType contentType() {
            return MEDIA_TYPE_MARKDOWN;
          }

          @Override public void writeTo(BufferedSink sink) throws IOException {

        .build(),
    )

    val requestBody = AsyncRequestBody()

    val call =
      client.newCall(
        Request(
          url = server.url("/"),
          body = requestBody,
        ),
      )

    call.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("abc")
      val requestBodyOut = requestBody.takeSink()
      assertFailsWith<IOException> {

import java.util.concurrent.TimeUnit.SECONDS
import okhttp3.MediaType
import okhttp3.RequestBody
import okio.BufferedSink
import org.junit.jupiter.api.Assertions.assertTrue

/** A duplex request body that keeps the provided sinks so they can be written to later.  */
class AsyncRequestBody : RequestBody() {
  private val requestBodySinks: BlockingQueue<BufferedSink> = LinkedBlockingQueue()

                            },
                        },
                    },
                    "summary": "Compute",
                    "operationId": "compute_a_compute_post",
                    "requestBody": {
                        "content": {
                            "application/json": {
                                "schema": {