그럼에도 두 경우 모두, **FastAPI**는 이전에 사용하던 프레임워크보다 [여전히 더 빠를](index.md#performance) 가능성이 높습니다(또는 최소한 비슷합니다).

### 의존성 { #dependencies }

[의존성](tutorial/dependencies/index.md)에도 동일하게 적용됩니다. 의존성이 `async def` 대신 표준 `def` 함수라면, 외부 스레드풀에서 실행됩니다.

### 하위 의존성 { #sub-dependencies }

import org.apache.maven.plugin.MojoExecution;
import org.apache.maven.plugin.descriptor.MojoDescriptor;

// TODO lifecycles being executed
// TODO what runs in each phase
// TODO plugins that need downloading
// TODO project dependencies that need downloading
// TODO unfortunately the plugins need to be downloaded in order to get the plugin.xml file. need to externalize this
//      from the plugin archive.

詳細は [Benchmarks](https://fastapi.tiangolo.com/ja/benchmarks/) セクションをご覧ください。

## 依存関係 { #dependencies }

FastAPI は Pydantic と Starlette に依存しています。

### `standard` 依存関係 { #standard-dependencies }

FastAPI を `pip install "fastapi[standard]"` でインストールすると、`standard` グループのオプション依存関係が含まれます。

Pydantic によって使用されるもの:

    pass  # pragma: nocover


callback_router5 = APIRouter()


@callback_router5.get("/")
async def callback5(level5: str):
    pass  # pragma: nocover


app = FastAPI(
    dependencies=[Depends(dep0)],
    responses={
        400: {"description": "Client error level 0"},
        500: {"description": "Server error level 0"},
    },
    default_response_class=ResponseLevel0,

     */
    private volatile boolean reconnecting;

    // Not serialized - will be null after deserialization
    private transient Object file; // Reference to SmbFile (avoid circular dependencies)

    /**
     * Create new handle information
     * @param path the file path
     * @param guid the create GUID
     * @param fileId the 16-byte file ID
     * @param type the handle type

                        .location("artifactId", location)
                        .location("version", location)
                        .executions(execs)
                        .dependencies(deps)
                        .build();

                plugins.put(key, plugin);
            }
        }
    }

    private static String getExecutionId(Plugin plugin, String goal) {

                sub.getTasks().register("extractedAssemble", task ->
                // We keep extracted configuration resolvable false to keep
                // resolveAllDependencies simple so we rely only on its build dependencies here.
                task.dependsOn(extractedConfiguration.getAllArtifacts().getBuildDependencies()));
            });
        });
        project.getExtensions().add("distribution_archives", container);
    }

Create a utility function to generate a new access token.

{* ../../docs_src/security/tutorial004_an_py310.py hl[4,7,13:15,29:31,82:90] *}

## Update the dependencies { #update-the-dependencies }

Update `get_current_user` to receive the same token as before, but this time, using JWT tokens.

Decode the received token, verify it, and return the current user.

        // For some reason with the introduction of MNG-1577 we have the case in Yoko where a depMan section has
        // something like the following:
        //
        // <dependencyManagement>
        //     <dependencies>
        //         <!--  Yoko modules -->
        //         <dependency>
        //             <groupId>org.apache.yoko</groupId>
        //             <artifactId>yoko-core</artifactId>

在这两种情况下，与你之前的框架相比，**FastAPI** 可能[仍然很快](index.md#performance)。

### 依赖 { #dependencies }

这同样适用于[依赖](tutorial/dependencies/index.md)。如果一个依赖是标准的 `def` 函数而不是 `async def`，它将被运行在外部线程池中。

### 子依赖 { #sub-dependencies }

你可以拥有多个相互依赖的依赖以及[子依赖](tutorial/dependencies/sub-dependencies.md) （作为函数的参数），它们中的一些可能是通过 `async def` 声明，也可能是通过 `def` 声明。它们仍然可以正常工作，这些通过 `def` 声明的函数将会在外部线程中调用（来自线程池），而不是"被等待"。