update sqlalchemy package to v2

Author: NatalyaGrigoreva

README.md

@@ -31,34 +31,34 @@ Create a test.py file and copy the following code into it
 
 ```python
 from pathlib import Path
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Optional
 
 import uvicorn
 from fastapi import APIRouter, Depends, FastAPI
 from pydantic import ConfigDict
-from sqlalchemy import Column, Integer, Text
 from sqlalchemy.engine import make_url
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 from fastapi_jsonapi import RoutersJSONAPI, init
 from fastapi_jsonapi.misc.sqla.generics.base import DetailViewBaseGeneric, ListViewBaseGeneric
 from fastapi_jsonapi.schema_base import BaseModel
 from fastapi_jsonapi.views.utils import HTTPMethod, HTTPMethodConfig
 from fastapi_jsonapi.views.view_base import ViewBase
 
-CURRENT_FILE = Path(__file__).resolve()
-CURRENT_DIR = CURRENT_FILE.parent
+CURRENT_DIR = Path(__file__).resolve().parent
 DB_URL = f"sqlite+aiosqlite:///{CURRENT_DIR}/db.sqlite3"
 
-Base = declarative_base()
+
+class Base(DeclarativeBase):
+    pass
 
 
 class User(Base):
     __tablename__ = "users"
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    name = Column(Text, nullable=True)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[Optional[str]]
 
 
 class UserAttributesBaseSchema(BaseModel):
@@ -81,38 +81,44 @@ class UserInSchema(UserAttributesBaseSchema):
     """User input schema."""
 
 
-def async_session() -> sessionmaker:
-    engine = create_async_engine(url=make_url(DB_URL))
-    _async_session = sessionmaker(bind=engine, class_=AsyncSession, expire_on_commit=False)
-    return _async_session
+def async_session() -> tuple[AsyncEngine, async_sessionmaker]:
+    engine_: AsyncEngine = create_async_engine(
+        url=f"{make_url(DB_URL)}",
+        echo=True,
+    )
+    session_maker_: async_sessionmaker[AsyncSession] = async_sessionmaker(
+        autocommit=False,
+        bind=engine,
+        expire_on_commit=False,
+    )
+    return engine_, session_maker_
+
+
+engine, session_maker = async_session()
 
 
 class Connector:
     @classmethod
-    async def get_session(cls):
-        """
-        Get session as dependency
-
-        :return:
-        """
-        sess = async_session()
-        async with sess() as db_session:  # type: AsyncSession
-            yield db_session
-            await db_session.rollback()
+    async def dispose(cls):
+        await engine.dispose()
 
+    @classmethod
+    async def init(cls) -> None:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
 
-async def sqlalchemy_init() -> None:
-    engine = create_async_engine(url=make_url(DB_URL))
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
+    @classmethod
+    async def session(cls):
+        async with session_maker() as db_session:
+            yield db_session
 
 
 class SessionDependency(BaseModel):
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
     )
 
-    session: AsyncSession = Depends(Connector.get_session)
+    session: AsyncSession = Depends(Connector.session)
 
 
 def session_dependency_handler(view: ViewBase, dto: SessionDependency) -> dict[str, Any]:
@@ -178,13 +184,15 @@ def create_app() -> FastAPI:
         docs_url="/docs",
     )
     add_routes(app)
-    app.on_event("startup")(sqlalchemy_init)
+    app.on_event("startup")(Connector.init)
+    app.on_event("shutdown")(Connector.dispose)
     init(app)
     return app
 
 
 app = create_app()
 
+
 if __name__ == "__main__":
     uvicorn.run(
         "main:app",

docs/python_snippets/client_generated_id/schematic_example.py

@@ -1,37 +1,39 @@
 import sys
 from pathlib import Path
-from typing import ClassVar, Annotated
+from typing import ClassVar, Annotated, Optional
 
 import uvicorn
 from fastapi import APIRouter, Depends, FastAPI
-from fastapi_jsonapi.schema_base import BaseModel
 from pydantic import ConfigDict
-from sqlalchemy import Column, Integer, Text
 from sqlalchemy.engine import make_url
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
+from examples.api_for_sqlalchemy.models.db import DB
 from fastapi_jsonapi import RoutersJSONAPI, init
 from fastapi_jsonapi.misc.sqla.generics.base import DetailViewBaseGeneric, ListViewBaseGeneric
+from fastapi_jsonapi.schema_base import BaseModel
 from fastapi_jsonapi.types_metadata import ClientCanSetId
 from fastapi_jsonapi.views.utils import HTTPMethod, HTTPMethodConfig
 from fastapi_jsonapi.views.view_base import ViewBase
 
 CURRENT_FILE = Path(__file__).resolve()
 CURRENT_DIR = CURRENT_FILE.parent
-PROJECT_DIR = CURRENT_DIR.parent.parent
-DB_URL = f"sqlite+aiosqlite:///{CURRENT_DIR.absolute()}/db.sqlite3"
-sys.path.append(f"{PROJECT_DIR}")
+sys.path.append(f"{CURRENT_DIR.parent.parent}")
+db = DB(
+    url=make_url(f"sqlite+aiosqlite:///{CURRENT_DIR.absolute()}/db.sqlite3"),
+)
 
-Base = declarative_base()
+
+class Base(DeclarativeBase):
+    pass
 
 
 class User(Base):
     __tablename__ = "users"
 
-    id = Column(Integer, primary_key=True, autoincrement=False)
-    name = Column(Text, nullable=True)
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[Optional[str]]
 
 
 class UserAttributesBaseSchema(BaseModel):
@@ -56,20 +58,8 @@ class UserInSchema(UserAttributesBaseSchema):
     id: Annotated[int, ClientCanSetId()]
 
 
-async def get_session():
-    sess = sessionmaker(
-        bind=create_async_engine(url=make_url(DB_URL)),
-        class_=AsyncSession,
-        expire_on_commit=False,
-    )
-    async with sess() as db_session:  # type: AsyncSession
-        yield db_session
-        await db_session.rollback()
-
-
 async def sqlalchemy_init() -> None:
-    engine = create_async_engine(url=make_url(DB_URL))
-    async with engine.begin() as conn:
+    async with db.engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
 
 
@@ -78,7 +68,7 @@ class SessionDependency(BaseModel):
         arbitrary_types_allowed=True,
     )
 
-    session: AsyncSession = Depends(get_session)
+    session: AsyncSession = Depends(db.session)
 
 
 def session_dependency_handler(view: ViewBase, dto: SessionDependency) -> dict:
@@ -145,16 +135,17 @@ def create_app() -> FastAPI:
     )
     add_routes(app)
     app.on_event("startup")(sqlalchemy_init)
+    app.on_event("shutdown")(db.dispose)
     init(app)
     return app
 
 
 app = create_app()
 
+
 if __name__ == "__main__":
-    current_file_name = CURRENT_FILE.name.replace(CURRENT_FILE.suffix, "")
     uvicorn.run(
-        f"{current_file_name}:app",
+        f"{CURRENT_FILE.name.replace(CURRENT_FILE.suffix, '')}:app",
         host="0.0.0.0",
         port=8084,
         reload=True,

docs/python_snippets/relationships/models.py

@@ -1,37 +1,36 @@
-from sqlalchemy import Column, Integer, String, ForeignKey
-from sqlalchemy.orm import relationship
+from __future__ import annotations
 
-from examples.api_for_sqlalchemy.extensions.sqlalchemy import Base
-from examples.api_for_sqlalchemy.utils.sqlalchemy.base_model_mixin import BaseModelMixin
+from typing import Optional
 
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import relationship, Mapped, mapped_column
 
-class User(Base, BaseModelMixin):
+from examples.api_for_sqlalchemy.models.base import Base
+
+
+class User(Base):
     __tablename__ = "users"
 
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    name = Column(String)
+    name: Mapped[str]
 
-    posts = relationship("Post", back_populates="user", uselist=True)
-    bio = relationship("UserBio", back_populates="user", uselist=False)
-    computers = relationship("Computer", back_populates="user", uselist=True)
+    bio: Mapped[UserBio] = relationship(back_populates="user")
+    computers: Mapped[list[Computer]] = relationship(back_populates="user")
 
 
-class Computer(Base, BaseModelMixin):
+class Computer(Base):
     __tablename__ = "computers"
 
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    name = Column(String, nullable=False)
+    name: Mapped[str]
 
-    user_id = Column(Integer, ForeignKey("users.id"), nullable=True)
-    user = relationship("User", back_populates="computers")
+    user_id: Mapped[Optional[int]] = mapped_column(ForeignKey("users.id"))
+    user: Mapped[User] = relationship(back_populates="computers")
 
 
-class UserBio(Base, BaseModelMixin):
+class UserBio(Base):
     __tablename__ = "user_bio"
 
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    birth_city = Column(String, nullable=False, default="", server_default="")
-    favourite_movies = Column(String, nullable=False, default="", server_default="")
+    birth_city: Mapped[str] = mapped_column(default="", server_default="")
+    favourite_movies: Mapped[str] = mapped_column(default="", server_default="")
 
-    user_id = Column(Integer, ForeignKey("users.id"), nullable=False, unique=True)
-    user = relationship("User", back_populates="bio", uselist=False)
+    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"), unique=True)
+    user: Mapped[User] = relationship(back_populates="bio")

docs/python_snippets/relationships/relationships_info_example.py

@@ -2,8 +2,7 @@
 
 from typing import Optional, Annotated
 
-from pydantic import BaseModel
-from pydantic import ConfigDict
+from pydantic import BaseModel, ConfigDict
 
 from fastapi_jsonapi.types_metadata import RelationshipInfo
 

docs/python_snippets/routing/router.py

@@ -1,11 +1,7 @@
 from fastapi import APIRouter, FastAPI
 
 from examples.api_for_sqlalchemy.models import User
-from examples.api_for_sqlalchemy.schemas import (
-    UserInSchema,
-    UserPatchSchema,
-    UserSchema,
-)
+from examples.api_for_sqlalchemy.schemas import UserInSchema, UserPatchSchema, UserSchema
 from fastapi_jsonapi import RoutersJSONAPI
 from fastapi_jsonapi.misc.sqla.generics.base import DetailViewBase, ListViewBase
 

docs/python_snippets/view_dependencies/main_example.py

@@ -1,57 +1,27 @@
-from __future__ import annotations
-
-from typing import ClassVar
+from typing import Optional, ClassVar
 
 from fastapi import Depends, Header
 from pydantic import BaseModel, ConfigDict
-from sqlalchemy.engine import make_url
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.ext.asyncio import create_async_engine
-from sqlalchemy.orm import sessionmaker
-from typing_extensions import Annotated, Optional
+from typing_extensions import Annotated
 
+from examples.api_for_sqlalchemy.models.db import DB
 from fastapi_jsonapi.exceptions import Forbidden
-from fastapi_jsonapi.misc.sqla.generics.base import (
-    DetailViewBaseGeneric,
-    ListViewBaseGeneric,
-)
-from fastapi_jsonapi.views.utils import (
-    HTTPMethod,
-    HTTPMethodConfig,
-)
+from fastapi_jsonapi.misc.sqla.generics.base import DetailViewBaseGeneric, ListViewBaseGeneric
+from fastapi_jsonapi.views.utils import HTTPMethod, HTTPMethodConfig
 from fastapi_jsonapi.views.view_base import ViewBase
 
-
-def get_async_sessionmaker() -> sessionmaker:
-    return sessionmaker(
-        bind=create_async_engine(
-            url=make_url(
-                f"sqlite+aiosqlite:///tmp/db.sqlite3",
-            )
-        ),
-        class_=AsyncSession,
-        expire_on_commit=False,
-    )
-
-
-async def async_session_dependency():
-    """
-    Get session as dependency
-
-    :return:
-    """
-    session_maker = get_async_sessionmaker()
-    async with session_maker() as db_session:  # type: AsyncSession
-        yield db_session
-        await db_session.rollback()
+db = DB(
+    url="sqlite+aiosqlite:///tmp/db.sqlite3",
+)
 
 
 class SessionDependency(BaseModel):
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
     )
 
-    session: AsyncSession = Depends(async_session_dependency)
+    session: AsyncSession = Depends(db.session)
 
 
 async def common_handler(view: ViewBase, dto: SessionDependency) -> dict:
@@ -80,7 +50,9 @@ class DetailView(DetailViewBaseGeneric):
 
 class ListView(ListViewBaseGeneric):
     method_dependencies: ClassVar[dict[HTTPMethod, HTTPMethodConfig]] = {
-        HTTPMethod.GET: HTTPMethodConfig(dependencies=AdminOnlyPermission),
+        HTTPMethod.GET: HTTPMethodConfig(
+            dependencies=AdminOnlyPermission,
+        ),
         HTTPMethod.ALL: HTTPMethodConfig(
             dependencies=SessionDependency,
             prepare_data_layer_kwargs=common_handler,

docs/requirements.txt

@@ -1,6 +1,6 @@
 fastapi>0.100.0
-orjson>=3.10.15
-pydantic>=2
+orjson>=3.2.1
+pydantic>=2.6.0
 sphinx
 sphinx_rtd_theme
-sqlalchemy<2
+sqlalchemy>=2.0.26