form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,

from typing import Optional


def say_hi(name: Optional[str]):

from docs_src.app_testing.tutorial002 import test_read_main, test_websocket


def test_main():
    test_read_main()


def test_ws():

         i) changes to the Program, and

         ii) additions to the Program;

where such changes and/or additions to the Program originate from and are
distributed by that particular Contributor. A Contribution 'originates' from
a Contributor if it was added to the Program by such Contributor itself or
anyone acting on such Contributor's behalf. Contributions do not include additions

from fastapi import FastAPI, HTTPException

app = FastAPI()

items = {"foo": "The Foo Wrestlers"}


@app.get("/items-header/{item_id}")
async def read_item_header(item_id: str):
    if item_id not in items:
        raise HTTPException(
            status_code=404,
            detail="Item not found",
            headers={"X-Error": "There goes my error"},
        )

from fastapi import FastAPI, Response, status

app = FastAPI()

tasks = {"foo": "Listen to the Bar Fighters"}


@app.put("/get-or-create-task/{task_id}", status_code=200)
def get_or_create_task(task_id: str, response: Response):
    if task_id not in tasks:
        tasks[task_id] = "This didn't exist before"
        response.status_code = status.HTTP_201_CREATED

    public String getUserProperty(String key) {
        return userProperties.get(key);
    }

    @Override
    public Model getRawModel(Path from, Path p) {
        return Holder.deref(modelByPath.get(p));
    }

    @Override
    public Model getRawModel(Path from, String groupId, String artifactId) {
        return Holder.deref(modelByGA.get(new GAKey(groupId, artifactId)));
    }

    @Override

## Managing hermetic Python

To make sure that TensorFlow's build is reproducible, behaves uniformly across
supported platforms (Linux, Windows, MacOS) and is properly isolated from
specifics of a local system, we rely on hermetic Python (see
[rules_python](https://github.com/bazelbuild/rules_python)) for all build
and test commands executed via Bazel. This means that your system Python
installation will be ignored during the build and Python interpreter itself

    unused = HostSpecifier.from(spec);
    assertTrue(HostSpecifier.isValid(spec));
  }

  private void assertBad(String spec) {
    try {
      HostSpecifier.fromValid(spec);
      fail("Should have thrown IllegalArgumentException: " + spec);
    } catch (IllegalArgumentException expected) {
    }

    try {
      HostSpecifier.from(spec);

/**
 * Assists in populating an execution request for invocation of Maven.
 *
 */
public interface MavenExecutionRequestPopulator {
    /**
     * Copies the values from the given toolchains into the specified execution request. This method will replace any
     * existing values in the execution request that are controlled by the toolchains. Hence, it is expected that this