```Python hl_lines="2  7-10 23-25"
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: bool | None = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str | None = None):

                return new BigDecimal("0.1");
            }

            @Override
            public String getQueryDefaultQueryType() {
                return "bool";
            }

            @Override
            public String getQueryBoostTitleLang() {
                return "1.0";
            }

            @Override

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

// It would be cool if there was a hook that I could use to set up a test environment.
// I want to set up a local/remote repositories for testing but I don't want to have
// to change them when I change the layout of the repositories. So I want to generate

	_, err := az.clnt.DeleteBlob(ctx, az.Bucket, az.getDest(object), &azblob.DeleteBlobOptions{})
	return azureToObjectError(err, az.Bucket, az.getDest(object))
}

func (az *warmBackendAzure) InUse(ctx context.Context) (bool, error) {
	maxResults := int32(1)
	pager := az.clnt.NewListBlobsFlatPager(az.Bucket, &azblob.ListBlobsFlatOptions{
		Prefix:     &az.Prefix,
		MaxResults: &maxResults,
	})
	if !pager.More() {
		return false, nil

	if derr.ReaderErr() == nil {
		t.Fatalf("missing expected underlying reader error")
	}
}

func TestDecoderMaxDepth(t *testing.T) {
	tests := []struct {
		input    string
		maxDepth int
		mustFail bool
	}{
		// No limit
		{input: `[{"bio":"bada bing bada boom","id":1,"name":"Charles","falseVal":false}]`, maxDepth: 0, mustFail: false},
		// Array + object = depth 2 = false

func newTestReaderEOF(data []byte) io.Reader {
	return &testOneByteReadEOF{false, data}
}

// OneByteReadEOF - implements io.Reader which returns 1 byte along with io.EOF error.
type testOneByteReadEOF struct {
	eof  bool
	data []byte
}

func (r *testOneByteReadEOF) Read(p []byte) (n int, err error) {
	if r.eof {
		return 0, io.EOF
	}
	n = copy(p, r.data)
	r.eof = true
	return n, io.EOF
}

### Configure the app `entrypoint` in `pyproject.toml` { #configure-the-app-entrypoint-in-pyproject-toml }

You can configure where your app is located in a `pyproject.toml` file like:

```toml
[tool.fastapi]
entrypoint = "main:app"
```

That `entrypoint` will tell the `fastapi` command that it should import the app like:

```python
from main import app
```

If your code was structured like:

### Den App-`entrypoint` in `pyproject.toml` konfigurieren { #configure-the-app-entrypoint-in-pyproject-toml }

Sie können in einer `pyproject.toml`-Datei konfigurieren, wo sich Ihre App befindet, z. B.:

```toml
[tool.fastapi]
entrypoint = "main:app"
```

Dieser `entrypoint` teilt dem `fastapi`-Befehl mit, dass er die App folgendermaßen importieren soll:

```python
from main import app
```

// `ancestor`.
//
// For example:
//
//	 	/a, /a/b, /a/b/c are all descendants of /a.
//		/abc or /abd/a are not descendants of /ab.
func (cp collectorPath) isDescendantOf(arg string) bool {
	descendant := string(cp)
	if descendant == arg {
		return true
	}
	if len(arg) >= len(descendant) {
		return false
	}
	if !strings.HasSuffix(arg, SlashSeparator) {
		arg += SlashSeparator
	}

pkg os/exec, method (ExitError) ExitCode() int
pkg reflect, method (*MapIter) Key() Value
pkg reflect, method (*MapIter) Next() bool
pkg reflect, method (*MapIter) Value() Value
pkg reflect, method (Value) MapRange() *MapIter
pkg reflect, type MapIter struct
pkg runtime/debug, func ReadBuildInfo() (*BuildInfo, bool)
pkg runtime/debug, type BuildInfo struct
pkg runtime/debug, type BuildInfo struct, Deps []*Module