}
        }

        Set<String> pathFilter = CollectionFactory.createFilePathSet();
        for (Path jarDir : jarDirs) {
            if (jarDir != null && Files.isDirectory(jarDir)) {
                try (DirectoryStream<Path> stream = Files.newDirectoryStream(jarDir, "*.jar")) {
                    for (Path jarFile : stream) {
                        String jarFileName = jarFile.getFileName().toString();

        when:
        URI jarUri = createJar()
        UriTextResource resource = new UriTextResource('<display-name>', jarUri, resolver)

        then:
        resource.displayName == "<display-name> '$jarUri'"
        resource.file == null
        resource.charset == null
        resource.location.file == null
        resource.location.URI == jarUri
    }

     * Creates a reference to the given path. Returns null for null path
     */
    public FileReference fromJarURI(String jarURI) {
        if (jarURI== null) {
            return null;
        }
        //cut the pre and postfix of this url
        URI fileURI = null;
        try {
            fileURI = new URI(jarURI.replace("jar:", "").replace("!/", ""));
        } catch (URISyntaxException e) {

                || f.name.contains("gradle-core")
                || f.name.contains("gradle-build-process-services")
            ) {
                GFileUtils.copyFile(f, new File(jarsDir, f.name))
            }
        }

        def testKitJar = jarsDir.listFiles().find { it.name.contains "test-kit" }
        buildFile << """
            dependencies {
                testImplementation fileTree(dir: 'jars', include: '*.jar')

        snapshot = snapshotter.snapshot(tarTree).snapshot

        then:
        assertSingleFileSnapshot(snapshot)

        when:
        def tarDir = tmpDir.createDir('tarDir')
        TestFile emptyTar = tempDir.file('emptyArchive.tar')
        tarDir.tarTo(emptyTar)
        def emptyTarTree = TestFiles.fileOperations(tempDir, testFileProvider()).tarTree(tar)
        snapshot = snapshotter.snapshot(emptyTarTree).snapshot

    password = user_dict["password"],
    email = user_dict["email"],
    full_name = user_dict["full_name"],
)
```

#### Um modelo Pydantic a partir do conteúdo de outro

Como no exemplo acima, obtivemos o `user_dict` a partir do `user_in.dict()`, este código:

```Python
user_dict = user_in.dict()
UserInDB(**user_dict)
```

seria equivalente a:

```Python

# Gelişmiş Güvenlik

## Ek Özellikler

[Tutorial - User Guide: Security](../../tutorial/security/index.md){.internal-link target=_blank} sayfasında ele alınanların dışında güvenlikle ilgili bazı ek özellikler vardır.

!!! tip "İpucu"
    Sonraki bölümler **mutlaka "gelişmiş" olmak zorunda değildir**.

    Kullanım şeklinize bağlı olarak, çözümünüz bu bölümlerden birinde olabilir.

## Önce Öğreticiyi Okuyun

    ```

=== "Python 3.8+"

    ```Python hl_lines="19-21"
    {!> ../../../docs_src/body_multiple_params/tutorial001.py!}
    ```

!!! note "Nota"
    Repare que, neste caso, o `item` que seria capturado a partir do corpo é opcional. Visto que ele possui `None` como valor padrão.

## Múltiplos parâmetros de corpo

No exemplo anterior, as *operações de rota* esperariam um JSON no corpo contendo os atributos de um `Item`, exemplo:

) {

    fun analyze(jarFile: File, classesDir: File, manifestFile: File, buildReceipt: File): ClassGraph {
        val classGraph = classGraph()

        val jarUri = URI.create("jar:${jarFile.toPath().toUri()}")
        FileSystems.newFileSystem(jarUri, emptyMap<String, Any>()).use { jarFileSystem ->
            jarFileSystem.rootDirectories.forEach {

```Python hl_lines="1"
{!../../../docs_src/python_types/tutorial005.py!}
```

### Tip parametreleri ile Generic tipler

"dict", "list", "set" ve "tuple" gibi diğer değerleri içerebilen bazı veri yapıları vardır. Ve dahili değerlerinin de tip belirtecleri olabilir.

Bu tipleri ve dahili tpileri bildirmek için standart Python modülünü "typing" kullanabilirsiniz.

Bu tür tip belirteçlerini desteklemek için özel olarak mevcuttur.