Artifact artifact = session.getArtifact(result.getArtifact());
                    Path path = result.getArtifact().getPath();
                    artifactManager.setPath(artifact, path);
                    paths.put(artifact, path);
                }
            }
            return () -> paths;
        } catch (ArtifactResolutionException e) {

     *
     * @param artifact the artifact for which to associate a path
     * @param path path to associate to the given artifact
     *
     * @see org.apache.maven.api.services.ArtifactManager#setPath(Artifact, Path)
     */
    void setArtifactPath(@Nonnull Artifact artifact, @Nonnull Path path);

    /**
     * Shortcut for {@code getService(ArtifactManager.class).getPath(...)}.
     *

        try {
            Path artifactPath = getProjectLocalRepo()
                    .resolve(project.getGroupId())
                    .resolve(project.getArtifactId())
                    .resolve(project.getVersion());
            if (Files.isDirectory(artifactPath)) {
                try (Stream<Path> paths = Files.list(artifactPath)) {
                    for (Path path : (Iterable<Path>) paths::iterator) {

import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Objects;

class PathSource implements ModelSource {

    private final Path path;
    private final String location;

    PathSource(Path path) {
        this(path, null);
    }

    PathSource(Path path, String location) {
        this.path = path;
        this.location = location != null ? location : path.toString();
    }

    @Override

<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```

</div>

If you use Hypercorn, it also has the option `--root-path`.

!!! note "Technical Details"
    The ASGI specification defines a `root_path` for this use case.

    And the `--root-path` command line option provides that `root_path`.

### Checking the current `root_path`

        this.timestamp = timestamp;
    }

    @Override
    public String getType() {
        return MAVEN_METADATA_XML;
    }

    @Deprecated
    @Override
    public File getFile() {
        return path != null ? path.toFile() : null;
    }

    @Override
    public Path getPath() {
        return path;
    }

    @Deprecated

                }
            }
        }
        Path path = paths.get(id);
        if (path == null && artifact instanceof DefaultArtifact) {
            path = ((DefaultArtifact) artifact).getArtifact().getPath();
        }
        return Optional.ofNullable(path);
    }

    @Override
    public void setPath(@Nonnull Artifact artifact, Path path) {
        String id = id(nonNull(artifact, "artifact"));

	_, err := storageUpdateMetadataRPC.Call(ctx, client.gridConn, &MetadataHandlerParams{
		DiskID:     *client.diskID.Load(),
		Volume:     volume,
		FilePath:   path,
		UpdateOpts: opts,
		FI:         fi,
	})
	return toStorageErr(err)
}

```Python hl_lines="3  25"
{!../../../docs_src/openapi_callbacks/tutorial001.py!}
```

### Create the callback *path operation*

To create the callback *path operation* use the same `APIRouter` you created above.

It should look just like a normal FastAPI *path operation*:

* It should probably have a declaration of the body it should receive, e.g. `body: InvoiceEvent`.

	return nil
}

func getValidPath(path string) (string, error) {
	if path == "" {
		return path, errInvalidArgument
	}

	var err error
	// Disallow relative paths, figure out absolute paths.
	path, err = filepath.Abs(path)
	if err != nil {
		return path, err
	}

	fi, err := Lstat(path)
	if err != nil && !osIsNotExist(err) {
		return path, err
	}
	if osIsNotExist(err) {