In our code example above, we don't use it directly, but we pass it to FastAPI for it to use it.

The `lifespan` parameter of the `FastAPI` app takes an **async context manager**, so we can pass our new `lifespan` async context manager to it.

{* ../../docs_src/events/tutorial003_py39.py hl[22] *}

                    pass = userInfo.substring(i + 1);
                    break;
                }
            }
            user = userInfo.substring(u, i);
        }

        this.domain = dom != null ? dom : defDomain != null ? defDomain : "";
        this.username = user != null ? user : defUser != null ? defUser : "";

There are 2 main differences from a normal *path operation*:

* It doesn't need to have any actual code, because your app will never call this code. It's only used to document the *external API*. So, the function could just have `pass`.

### Include the custom docs { #include-the-custom-docs }

Now you can create the *path operations* for the custom docs.

You can reuse FastAPI's internal functions to create the HTML pages for the docs, and pass them the needed arguments:

* `openapi_url`: the URL where the HTML page for the docs can get the OpenAPI schema for your API. You can use here the attribute `app.openapi_url`.
* `title`: the title of your API.

Isso pode ser útil se, por exemplo, você mora em um país que restringe algumas URLs.

### Desativar a documentação automática { #disable-the-automatic-docs }

O primeiro passo é desativar a documentação automática, pois por padrão, ela usa o CDN padrão.

Para desativá-los, defina suas URLs como `None` ao criar sua aplicação FastAPI:

{* ../../docs_src/custom_docs_ui/tutorial001_py39.py hl[8] *}

    // Trigger any exception that the comparator would throw for the endpoints.
    /*
     * uncheckedCastNullableTToT is safe as long as the callers are careful to pass a "real" T
     * whenever they pass `true` for the matching `has*Bound` parameter.
     */
    if (hasLowerBound) {
      int unused =
          comparator.compare(

* Crie um objeto `templates` que você possa reutilizar posteriormente.
* Declare um parâmetro `Request` no *path operation* que retornará um template.
* Use o `templates` que você criou para renderizar e retornar uma `TemplateResponse`, passe o nome do template, o objeto `request` e um dicionário "context" com pares chave-valor a serem usados dentro do template do Jinja2.

{* ../../docs_src/templates/tutorial001_py39.py hl[4,11,15:18] *}

/// note | Nota

//
// passes NOATIME flag for reads on Unix systems to avoid atime updates.
func ReadFile(name string) ([]byte, error) {
	// Don't wrap with un-needed buffer.
	// Don't use os.ReadFile, since it doesn't pass NO_ATIME when present.
	f, err := OsOpenFile(name, readMode, 0o666)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	st, err := f.Stat()
	if err != nil {
		return io.ReadAll(f)
	}

            verify(mockRenewableCredentials, never()).renew(); // Ensure renewable path was not taken
        }
    }

    @Test
    @DisplayName("Should pass SmbAuthException to NtlmAuthenticator.requestNtlmPasswordAuthentication")
    void testRenewCredentials_WithSmbAuthException() {
        SmbAuthException mockSmbAuthException = mock(SmbAuthException.class);

            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_set_header X-NginX-Proxy true;

            # This is necessary to pass the correct IP to be hashed
            real_ip_header X-Real-IP;

            proxy_connect_timeout 300;
            
            # To support websocket
            proxy_http_version 1.1;