You can use the same dependency *functions* you use normally.

### Dependency requirements { #dependency-requirements }

They can declare request requirements (like headers) or other sub-dependencies:

{* ../../docs_src/dependencies/tutorial006_an_py39.py hl[8,13] *}

### Raise exceptions { #raise-exceptions }

These dependencies can `raise` exceptions, the same as normal dependencies:

/// warning

This is a more or less advanced section. If you are just starting, you can skip it.

You don't necessarily need OAuth2 scopes, and you can handle authentication and authorization however you want.

But OAuth2 with scopes can be nicely integrated into your API (with OpenAPI) and your API docs.

 * providing name service, datagram service, and session service to the
 * Microsoft Windows platform. A NetBIOS name can be 15 characters long
 * and hosts usually registers several names on the network. From a
 * Windows command prompt you can see
 * what names a host registers with the nbtstat command.
 *
 *  * <blockquote>
 *
 * <pre>
 * C:\&gt;nbtstat -a 192.168.1.15
 *

      value: >
        Comparing two approaches to a use case side by side can make it easier to examine the
        differences between them.


        Additionally, it's very useful to us if you can provide a "straw API" — what the
        method signatures would look like, for example, even if the method and class names are still
        in flux. This can make the feature you're suggesting much clearer to us.

  - type: textarea

import org.apache.maven.api.Service;
import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nonnull;

/**
 * Service for creating {@link PathMatcher} objects that can be used to filter files
 * based on include/exclude patterns. This service provides a clean API for plugins
 * to create path matchers without directly depending on implementation classes.
 * <p>

# Extra Data Types { #extra-data-types }

Up to now, you have been using common data types, like:

* `int`
* `float`
* `str`
* `bool`

But you can also use more complex data types.

And you will still have the same features as seen up to now:

* Great editor support.
* Data conversion from incoming requests.
* Data conversion for response data.
* Data validation.
* Automatic annotation and documentation.

   * higher value than you need can waste space and time, and a significantly lower value can lead
   * to thread contention. But overestimates and underestimates within an order of magnitude do not
   * usually have much noticeable impact. A value of one permits only one thread to modify the cache
   * at a time, but since read operations and cache loading computations can proceed concurrently,

# `Response` class

You can declare a parameter in a *path operation function* or dependency to be of type `Response` and then you can set data for the response like headers or cookies.

You can also use it directly to create an instance of it and return it from your *path operations*.

You can import it directly from `fastapi`:

```python
from fastapi import Response
```

  ) {
  }

  /**
   * Invoked just prior to initiating a socket connection.
   *
   * This method will be invoked if no existing connection in the [ConnectionPool] can be reused.
   *
   * This can be invoked more than 1 time for a single [Call]. For example, if the response to the
   * [Call.request] is a redirect to a different address, or a connection is retried.
   */
  open fun connectStart(

///

## Await for messages and send messages { #await-for-messages-and-send-messages }

In your WebSocket route you can `await` for messages and send messages.

{* ../../docs_src/websockets/tutorial001.py hl[48:52] *}

You can receive and send binary, text, and JSON data.

## Try it { #try-it }

If your file is named `main.py`, run your application with:

<div class="termy">