}

    @Nonnull
    default DependencyResolverResult resolve(@Nonnull Session session, @Nonnull Project project) {
        return resolve(
                DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.RESOLVE, project));
    }

    @Nonnull
    default DependencyResolverResult resolve(
            @Nonnull Session session, @Nonnull Project project, @Nonnull PathScope scope) {

        // Setup request session
        lenient().when(request.getSession()).thenReturn(session);
        lenient().when(request.getSession(false)).thenReturn(session);
        lenient().when(request.getSession(true)).thenReturn(session);

        // Setup default session attribute behavior
        lenient().when(session.getAttribute(anyString())).thenReturn(null);

    void testGettersAndState() {
        SmbSessionImpl session = newSession();

        // Basic getters
        assertSame(configuration, session.getConfig(), "getConfig delegates to transportContext");
        assertEquals("EXAMPLE", session.getTargetDomain());
        assertEquals("server.example", session.getTargetHost());
        assertTrue(session.isInUse(), "New session starts in-use (usageCount=1)");

    }

    @NotThreadSafe
    class VersionResolverRequestBuilder {
        Session session;
        RequestTrace trace;
        ArtifactCoordinates artifactCoordinates;
        List<RemoteRepository> repositories;

        public VersionResolverRequestBuilder session(Session session) {
            this.session = session;
            return this;
        }

    class ArtifactResolverRequestBuilder {
        Session session;
        RequestTrace trace;
        Collection<? extends ArtifactCoordinates> coordinates;
        List<RemoteRepository> repositories;

        ArtifactResolverRequestBuilder() {}

        @Nonnull
        public ArtifactResolverRequestBuilder session(Session session) {
            this.session = session;
            return this;
        }

        @Nonnull

def get_session():
    with Session(engine) as session:
        yield session


SessionDep = Annotated[Session, Depends(get_session)]

app = FastAPI()


@app.on_event("startup")
def on_startup():
    create_db_and_tables()


@app.post("/heroes/")
def create_hero(hero: Hero, session: SessionDep) -> Hero:
    session.add(hero)
    session.commit()
    session.refresh(hero)
    return hero

            @Nonnull Session session,
            @Nonnull ArtifactCoordinates artifactCoordinates,
            @Nullable List<RemoteRepository> repositories) {
        return build(session, artifactCoordinates, repositories, null);
    }

    /**
     * Creates a version range resolver request.
     *
     * @param session the session to use, must not be {@code null}

        session.withLocalRepositories(new LocalRepository(new File("target/local-repo"), "simple"));
        session.setTransferListener(new ConsoleTransferListener());
        session.setRepositoryListener(new ConsoleRepositoryListener());

        return session.build();
    }

    public static RemoteRepository newTestRepository() throws MalformedURLException {
        return new RemoteRepository.Builder(
                        "repo",

        this.session = session.withRemoteRepositories(Collections.singletonList(remoteRepository));
        InternalSession.associate(rss, this.session);
        sessionScope.enter();
        sessionScope.seed(InternalMavenSession.class, InternalMavenSession.from(this.session));
    }

    private Project project(Artifact artifact) {
        return session.getService(ProjectBuilder.class)

    }

    /**
     * Retrieves or creates the result document IDs cache from the session.
     * The cache is implemented as an LRU map to limit memory usage.
     *
     * @param session the HTTP session
     * @return the result document IDs cache map
     */
    private Map<String, String[]> getResultDocIdsCache(final HttpSession session) {
        @SuppressWarnings("unchecked")