### Run Automatically on Startup { #run-automatically-on-startup }

In general, you will probably want the server program (e.g. Uvicorn) to be started automatically on server startup, and without needing any **human intervention**, to have a process always running with your API (e.g. Uvicorn running your FastAPI app).

}
```

### Custom OpenAPI *path operation* schema { #custom-openapi-path-operation-schema }

The dictionary in `openapi_extra` will be deeply merged with the automatically generated OpenAPI schema for the *path operation*.

So, you could add additional data to the automatically generated schema.

Let's say your file is named `myapp.py`.

If you run it with:

<div class="termy">

```console
$ python myapp.py
```

</div>

then the internal variable `__name__` in your file, created automatically by Python, will have as value the string `"__main__"`.

So, the section:

```Python
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

will run.

---

            This pull request has been automatically marked as stale because it has not had recent activity.
            It will be closed in 14 days if no further activity occurs.
            If you don't want the stale bot to close it, then set a milestone for it.
          days-before-pr-close: 14
          close-pr-message: >

 *       divided into segments, each of which does LRU internally)
 *   <li>time-based expiration of entries, measured since last access or last write
 *   <li>keys automatically wrapped in {@code WeakReference}
 *   <li>values automatically wrapped in {@code WeakReference} or {@code SoftReference}
 *   <li>notification of evicted (or otherwise removed) entries
 *   <li>accumulation of cache access statistics
 * </ul>
 *

            this.supplier = supplier;
        }

        /**
         * Executes the provided {@link Consumer} with a {@link Stream} obtained from the supplier.
         * The stream is automatically closed after the consumer is executed.
         *
         * @param stream the {@link Consumer} to process the {@link Stream}
         */
        public void of(final Consumer<Stream<T>> stream) {

import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletResponse;

/**
 * Default implementation of CORS (Cross-Origin Resource Sharing) handler.
 * This handler automatically registers itself for origins configured in the system
 * and applies standard CORS headers based on the application configuration.
 */
public class DefaultCorsHandler extends CorsHandler {

    /**

```
testImplementation("com.squareup.okhttp3:mockwebserver3-junit5:5.1.0")
```

Annotate fields in test classes with `@StartStop`. The server will be started and shut down
automatically.

```
class MyTest {

  @StartStop
  public final MockWebServer server = new MockWebServer();

  @Test
  void test() {
    ...
  }
}
```

Requirements
------------

=============

If you use OkHttp as a dependency in an Android project which uses R8 as a default compiler you
don't have to do anything. The specific rules are [already bundled][okhttp3_pro] into the JAR which can be
interpreted by R8 automatically.

If you, however, don't use R8 you have to apply the rules from [this file][okhttp3_pro]. You might
also need rules from [Okio][okio] which is a dependency of this library.

 */
@GwtCompatible
@NullMarked
final class RelationshipTester<T> {
  interface ItemReporter {
    String reportItem(Item<?> item);
  }

  /**
   * A word about using {@link Equivalence}, which automatically checks for {@code null} and
   * identical inputs: This sounds like it ought to be a problem here, since the goals of this class
   * include testing that {@code equals()} is reflexive and is tolerant of {@code null}. However,