public NativePlatformBackedStat(PosixFiles posixFiles) {
        this.posixFiles = posixFiles;
    }

    @Override
    public int getUnixMode(File f) {
        return posixFiles.getMode(f, true);
    }

			err := resource.UnmarshalTo(&clientConfig)
			if err != nil {
				return nil, nil, fmt.Errorf("could not unmarshal ClientConfig: %w", err)
			}
			meta, err := model.ParseMetadata(clientConfig.GetNode().GetMetadata())
			if err != nil {
				return nil, nil, fmt.Errorf("could not parse node metadata: %w", err)
			}
			if s.Namespace != "" && meta.Namespace != s.Namespace {
				continue
			}

            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(8, "unix_file_permissions_deprecated")
            .nagUser();
        return getMode(buildRootResolver().getFilePermissions());
    }

    @Nullable
    private Integer getMode(Provider<ConfigurableFilePermissions> permissions) {
        return permissions.map(FilePermissions::toUnixNumeric).getOrNull();
    }

    @Override

    }

    TestFile file(String name) {
        baseDir.file(name).createFile()
    }

    TestFile link(String name, String target) {
        baseDir.file(name).createLink(target)
    }

    def setMode(int mode) {
        baseDir.mode = mode
    }

    def methodMissing(String name, Object args) {
        if (args.length == 1 && args[0] instanceof Closure) {
            baseDir.file(name).create(args[0])

`user_in` ist ein Pydantic-Modell der Klasse `UserIn`.

Pydantic-Modelle haben eine `.dict()`-Methode, die ein `dict` mit den Daten des Modells zurückgibt.

Wenn wir also ein Pydantic-Objekt `user_in` erstellen, etwa so:

```Python
user_in = UserIn(username="john", password="secret", email="******@****.***")
```

und wir rufen seine `.dict()`-Methode auf:

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

                    session.getRepositorySystem().collectDependencies(systemSession, collectRequest);
            return new DefaultDependencyResolverResult(
                    null, result.getExceptions(), session.getNode(result.getRoot(), request.getVerbose()), 0);
        } catch (DependencyCollectionException e) {
            throw new DependencyResolverException("Unable to collect dependencies", e);
        }
    }

    @Override

func NewRegistrationHandler(kubeClient kubernetes.Interface, getNode func() (*v1.Node, error)) *RegistrationHandler {
	handler := &RegistrationHandler{}

	// If kubelet ever gets an API for stopping registration handlers, then
	// that would need to be hooked up with stopping the controller.
	handler.controller = startNodeResourcesController(context.TODO(), kubeClient, getNode)

	return handler
}

    }

    @Override
    public void exclude() {
        excluded = true;
    }

    @Override
    @Deprecated
    public void setMode(int mode) {
        DeprecationLogger.deprecateMethod(CopyProcessingSpec.class, "setMode()")
            .replaceWith("permissions(Action)")
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(8, "unix_file_permissions_deprecated")

        return getRelativePath().getPathString();
    }

    @Override
    public RelativePath getRelativePath() {
        return relativePath;
    }

    @Override
    @Deprecated
    public int getMode() {
        throw new UnsupportedOperationException();
    }

    @Override
    public FilePermissions getPermissions() {
        throw new UnsupportedOperationException();
    }

    }

    @Override
    public FileLock lock(File target, LockOptions options, String targetDisplayName, String operationDisplayName, @Nullable Consumer<FileLockReleasedSignal> whenContended) {
        if (options.getMode() == LockMode.OnDemand) {
            throw new UnsupportedOperationException(String.format("No %s mode lock implementation available.", options));
        }
        File canonicalTarget;
        try {