assertThat(request.tag(Any::class.java)).isNull()
    assertThat(request.tag(UUID::class.java)).isNull()
    assertThat(request.tag(String::class.java)).isNull()

    // Alternate access APIs also work.
    assertThat(request.tag<String>()).isNull()
    assertThat(request.tag(String::class)).isNull()
  }

  @Test
  fun defaultTag() {
    val tag = UUID.randomUUID()
    val request =

// He works in a Company (belongs to), he has a Manager (belongs to - single-table), and also managed a Team (has many - single-table)
// He speaks many languages (many to many) and has many friends (many to many - single-table)
// His pet also has one Toy (has one - polymorphic)
// NamedPet is a reference to a named `Pet` (has one)
type User struct {
	gorm.Model
	Name      string

///

/// note | Technical Details

You could also use `from starlette.requests import Request`.

**FastAPI** provides it as a convenience for you, the developer. But it comes directly from Starlette.

///

### Before and after the `response` { #before-and-after-the-response }

You can add code to be run with the `request`,  before any *path operation* receives it.

And also after the `response` is generated, before returning it.

The spec also states that the `username` and `password` must be sent as form data (so, no JSON here).

### `scope` { #scope }

The spec also says that the client can send another form field "`scope`".

  
  project4["project"]
  build2 --> project4

```

### Build process state

The "build process state" holds the global state of the build process and manages all the other state.

The build process state also includes state that is tied to a particular Gradle user home directory.
When that directory changes between Gradle invocations, the state is discarded and recreated.

        .build()
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    assertFailsWith<IllegalStateException> {
      client.newCall(request).execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "network interceptor $interceptor must call proceed() exactly once",
      )
    }
  }

  @Test

    /**
     * Indicates whether Maven should also build the specified projects' dependencies.
     *
     * @return an {@link Optional} containing true if dependencies should also be built, false if not, or empty if not specified
     */
    @Nonnull
    Optional<Boolean> alsoMake();

    /**
     * Indicates whether Maven should also build the specified projects' dependents.
     *

**FastAPI** will use that *temporal* response to extract the status code (also cookies and headers), and will put them in the final response that contains the value you returned, filtered by any `response_model`.

/// note | Technical Details

A `Request` has a `request.scope` attribute, that's just a Python `dict` containing the metadata related to the request.

A `Request` also has a `request.receive`, that's a function to "receive" the body of the request.

The `scope` `dict` and `receive` function are both part of the ASGI specification.

    <offline>true</offline>
    ]]></configuration>
      <description>
        <![CDATA[
      Flags the system as offline, to prevent accessing the network to resolve artifacts or execute plugins.

      NOTE: It's also possible to switch to offline mode on a per-build basis, using the '-o' command-line option.
    ]]></description>
    </expression>
    <expression>
      <syntax>settings.interactiveMode</syntax>
      <configuration>