false), MESSAGE_TOO_LARGE("Message too large", ErrorCategory.PROTOCOL, false),

        // Resource errors
        OUT_OF_MEMORY("Out of memory", ErrorCategory.RESOURCE, true), TOO_MANY_SESSIONS("Too many sessions", ErrorCategory.RESOURCE,
                true), RESOURCE_LOCKED("Resource is locked", ErrorCategory.RESOURCE, true),

        // Transient errors

    /**
     * Gets or creates the cached Maven 4 session.
     */
    private Session getSession() {
        if (session == null) {
            session = createMaven4Session();
        }
        return session;
    }

    /**
     * Creates a new Maven 4 session for effective POM computation.
     */
    private Session createMaven4Session() {
        Session session = ApiRunner.createSession(injector -> {

     */
    @Nonnull
    default ProjectBuilderResult build(@Nonnull Session session, @Nonnull Source source)
            throws ProjectBuilderException {
        return build(ProjectBuilderRequest.build(session, source));
    }

    /**
     * Creates a {@link org.apache.maven.api.Project} from a POM file.
     *
     * @param session the {@link Session}, must not be {@code null}

        Key cacheKey = null;
        RepositoryCache cache = session.getCache();
        if (cache != null && !ConfigUtils.getBoolean(session, false, "aether.versionResolver.noCache")) {
            cacheKey = new Key(session, request);

            Object obj = cache.get(session, cacheKey);
            if (obj instanceof Record record) {
                result.setVersion(record.version);

                        toProperties(session.getUserProperties(), session.getSystemProperties()));
                modelRequest.setUserProperties(new Properties());
                modelRequest.setModelCache(modelCacheFactory.createCache(session));
                modelRequest.setModelResolver(new DefaultModelResolver(
                        session,
                        trace.newChild(modelRequest),

        try {
            Result<ProjectDependencyGraph> result = sessionDependencyGraph(session);

            if (result == null) {
                final List<MavenProject> projects = getProjectsForMavenReactor(session);
                validateProjects(projects, session.getRequest());
                processPackagingAttribute(projects, session.getRequest());

    private final RepositorySystemSession session;

    private final RepositoryCache cache;

    public static ModelCache newInstance(RepositorySystemSession session) {
        if (session.getCache() == null) {
            return null;
        } else {
            return new DefaultModelCache(session);
        }
    }

    private DefaultModelCache(RepositorySystemSession session) {
        this.session = session;

    private MavenSession session;

    private MojoExecution mojoExecution;

    private MavenProject project;

    private String basedir;

    private Properties properties;

    public PluginParameterExpressionEvaluator(MavenSession session) {
        this(session, null);
    }

    public PluginParameterExpressionEvaluator(MavenSession session, MojoExecution mojoExecution) {

abstract class BaseRequest<S extends ProtoSession> implements Request<S> {

    private final S session;
    private final RequestTrace trace;

    protected BaseRequest(@Nonnull S session) {
        this(session, null);
    }

    protected BaseRequest(@Nonnull S session, RequestTrace trace) {
        this.session = requireNonNull(session, "session cannot be null");
        this.trace = trace;
    }

    @Nonnull
    @Override

from sqlmodel import Field, Session, SQLModel, create_engine

engine = create_engine("postgresql+psycopg://postgres:postgres@localhost/db")


class User(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str


app = FastAPI()


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