//// tab | Python 3.8+

```Python hl_lines="1  20"
{!> ../../docs_src/extra_models/tutorial004.py!}
```

////

## Response with arbitrary `dict`

You can also declare a response using a plain arbitrary `dict`, declaring just the type of the keys and values, without using a Pydantic model.

This is useful if you don't know the valid field/attribute names (that would be needed for a Pydantic model) beforehand.

   * possible with an unsafe cast which requires {@code keys} to actually be of type {@code K}.
   *
   * @since 11.0
   */
  /*
   * <? extends Object> is mostly the same as <?> to plain Java. But to nullness checkers, they
   * differ: <? extends Object> means "non-null types," while <?> means "all types."
   */
  @Override
  public ImmutableMap<K, V> getAllPresent(Iterable<? extends Object> keys) {

	uploadID := ""
	if len(params) >= 1 {
		bucket = params[0]
	}
	if len(params) == 2 {
		object = params[1]
	}
	if len(params) == 3 {
		uploadID = params[2]
	}

	// in some cases just a plain error is being returned
	switch err.Error() {
	case "storage: bucket doesn't exist":
		err = BucketNotFound{
			Bucket: bucket,
		}
		return err
	case "storage: object doesn't exist":
		if uploadID != "" {

    connection!!.idleAtNs -= IDLE_CONNECTION_HEALTHY_NS
    Thread.sleep(250)

    val requestB =
      Request(
        url = server.url("/"),
        body = "b".toRequestBody("text/plain".toMediaType()),
      )
    val responseB = client.newCall(requestB).execute()
    assertThat(responseB.body.string()).isEqualTo("b")
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
  }

            } else if (lowerPath.endsWith(".ttf")) {
                response.setContentType("font/ttf");
            } else if (lowerPath.endsWith(".txt")) {
                response.setContentType("text/plain");
            } else if (lowerPath.endsWith(".woff")) {
                response.setContentType("font/woff");
            } else if (lowerPath.endsWith(".woff2")) {
                response.setContentType("font/woff2");

  }

  @Test fun binarySearchEmptyRange() {
    assertEquals(-1, binarySearch(0, 0) { error("unexpected call") })
  }

  /** Confirm the compact table has the exact same behavior as the plain table. */
  @Test fun comparePlainAndCompactTables() {
    val buffer = Buffer()
    for (codePoint in 0..0x10ffff) {
      val allowedByTable = table.map(codePoint, buffer)
      val tableMappedTo = buffer.readUtf8()

  }

  private fun sleepingRequestBody(sleepMillis: Int): RequestBody {
    return object : RequestBody() {
      override fun contentType(): MediaType? {
        return "text/plain".toMediaTypeOrNull()
      }

      @Throws(IOException::class)
      override fun writeTo(sink: BufferedSink) {
        try {
          sink.writeUtf8("abc")
          sink.flush()

                        .message(fieldDescription)
                        .defaultValue(field.getDefaultValue().get())
                        .addPrompt();
            } else {
                // ? plain input?
                promptBuilder
                        .createInputPrompt()
                        .name(fieldKey)
                        .message(fieldDescription)
                        .addPrompt();

        goodCertificate.certificate,
      )
    server.useHttps(socketFactory)
    server.enqueue(
      MockResponse.Builder()
        .body("abc")
        .addHeader("Content-Type: text/plain")
        .build(),
    )

    // Make a request from client to server. It should succeed certificate checks (unfortunately the
    // rogue CA is trusted) but it should fail certificate pinning.
    val request =

    body.byteStream().close()
    assertThat(closed.get()).isTrue()
  }

  @Test
  fun unicodeTextWithUnsupportedEncoding() {
    val text = "eile oli oliiviõli"
    val body = text.toResponseBody("text/plain; charset=unknown".toMediaType())
    assertThat(body.string()).isEqualTo(text)
  }

  companion object {
    @JvmOverloads
    fun body(
      hex: String,
      charset: String? = null,