* **Robust**: Get production-ready code. With automatic interactive documentation.

}

type format struct {
	ID string `json:"id"`
	XL xl     `json:"xl"`
}

func getMountMap() (map[string]string, error) {
	result := make(map[string]string)

	mountInfo, err := os.Open("/proc/self/mountinfo")
	if err != nil {
		return nil, err
	}
	defer mountInfo.Close()

	scanner := bufio.NewScanner(mountInfo)
	for scanner.Scan() {
		s := strings.Split(scanner.Text(), " ")

```Python hl_lines="6-7"
{!../../docs_src/query_params/tutorial005.py!}
```

Here the query parameter `needy` is a required query parameter of type `str`.

If you open in your browser a URL like:

```
http://127.0.0.1:8000/items/foo-item
```

...without adding the required parameter `needy`, you will see an error like:

```JSON
{
  "detail": [
    {

Up to here, everything would work as normally.

But then, when you open the integrated docs UI (the frontend), it would expect to get the OpenAPI schema at `/openapi.json`, instead of `/api/v1/openapi.json`.

	if err != nil {
		in.Error("unquoting include file name: ", err)
	}
	in.expectNewline("#include")
	// Push tokenizer for file onto stack.
	fd, err := os.Open(name)
	if err != nil {
		for _, dir := range in.includes {
			fd, err = os.Open(filepath.Join(dir, name))
			if err == nil {
				break
			}
		}
		if err != nil {
			in.Error("#include:", err)
		}
	}

{!../../docs_src/custom_response/tutorial007.py!}
```

#### Utilizando `StreamingResponse` com objetos semelhantes a arquivos

Se você tiver um objeto semelhante a um arquivo (e.g. o objeto retornado por `open()`), você pode criar uma função geradora para iterar sobre esse objeto.

Dessa forma, você não precisa ler todo o arquivo na memória primeiro, e você pode passar essa função geradora para `StreamingResponse` e retorná-la.

			if err != nil {
				return nil, err
			}
			readers = append(readers, rs)
		}
	}
	return readers, nil
}

func gatherFile(f string) (local.ReaderSource, error) {
	r, err := os.Open(f)
	if err != nil {
		return local.ReaderSource{}, err
	}
	runtime.SetFinalizer(r, func(x *os.File) {
		err = x.Close()
		if err != nil {
			log.Infof("file : %s is not closed: %v", f, err)
		}
	})

      } else {
        pos++ // Consume '='.
        pos = value.indexOfNonWhitespace(pos)

        if (pos < value.length && value[pos] == '\"') {
          // Quoted string.
          pos++ // Consume '"' open quote.
          val parameterStart = pos
          pos = value.indexOf('"', pos)
          parameter = value.substring(parameterStart, pos)
          pos++ // Consume '"' close quote (if necessary).
        } else {

		"The json file with Envoy config dump to be checked")
	return cmd
}

func getConfigDumpFromFile(filename string) (*configdump.Wrapper, error) {
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer func() {
		if err := file.Close(); err != nil {
			log.Errorf("failed to close %s: %s", filename, err)
		}
	}()
	data, err := io.ReadAll(file)

import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.stream.Stream;

/**
 * A destination to which characters can be written, such as a text file. Unlike a {@link Writer}, a
 * {@code CharSink} is not an open, stateful stream that can be written to and closed. Instead, it
 * is an immutable <i>supplier</i> of {@code Writer} instances.
 *
 * <p>{@code CharSink} provides two kinds of methods:
 *
 * <ul>