SQLAlchemy 2.0 (#78)

Author: grigoriev-semyon

calendar_backend/models/base.py

@@ -6,7 +6,7 @@
 from sqlalchemy import Column, Integer, not_
 from sqlalchemy.exc import NoResultFound
 from sqlalchemy.ext.declarative import as_declarative, declared_attr
-from sqlalchemy.orm import Query, Session
+from sqlalchemy.orm import Query, Session, Mapped, mapped_column
 
 from calendar_backend.exceptions import ObjectNotFound
 
@@ -31,7 +31,7 @@ def __tablename__(cls) -> str:  # pylint: disable=no-self-argument
 
 class BaseDbModel(DeclarativeBase):
     __abstract__ = True
-    id = Column(Integer, primary_key=True)
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
 
     def __repr__(self):
         attrs = []

calendar_backend/models/db.py

@@ -5,26 +5,24 @@
 from datetime import datetime
 from enum import Enum
 
-import sqlalchemy
-from sqlalchemy import Column
+from sqlalchemy import and_, or_, Integer, String, Boolean, JSON, DateTime, Text, ForeignKey, true
 from sqlalchemy import Enum as DbEnum
-from sqlalchemy import and_, or_
 from sqlalchemy.ext.hybrid import hybrid_method, hybrid_property
-from sqlalchemy.orm import relationship
+from sqlalchemy.orm import relationship, Mapped, mapped_column
 
 from .base import BaseDbModel, ApproveStatuses
 
 
 class Credentials(BaseDbModel):
     """User credentials"""
 
-    id = Column(sqlalchemy.Integer, primary_key=True)
-    group = Column(sqlalchemy.String, nullable=False)
-    email = Column(sqlalchemy.String, nullable=False)
-    scope = Column(sqlalchemy.JSON, nullable=False)
-    token = Column(sqlalchemy.JSON, nullable=False)
-    create_ts = Column(sqlalchemy.DateTime, nullable=False, default=datetime.utcnow)
-    update_ts = Column(sqlalchemy.DateTime, nullable=False, default=datetime.utcnow, onupdate=datetime.utcnow)
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    group: Mapped[int] = mapped_column(String, nullable=False)
+    email: Mapped[int] = mapped_column(String, nullable=False)
+    scope: Mapped[int] = mapped_column(JSON, nullable=False)
+    token: Mapped[int] = mapped_column(JSON, nullable=False)
+    create_ts: Mapped[int] = mapped_column(DateTime, nullable=False, default=datetime.utcnow)
+    update_ts: Mapped[int] = mapped_column(DateTime, nullable=False, default=datetime.utcnow, onupdate=datetime.utcnow)
 
 
 class Direction(str, Enum):
@@ -33,12 +31,12 @@ class Direction(str, Enum):
 
 
 class Room(BaseDbModel):
-    name = sqlalchemy.Column(sqlalchemy.String, nullable=False, unique=True)
-    direction = sqlalchemy.Column(DbEnum(Direction, native_enum=False), nullable=True)
-    building = sqlalchemy.Column(sqlalchemy.String)
-    is_deleted = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
+    name: Mapped[int] = mapped_column(String, nullable=False, unique=True)
+    direction: Mapped[int] = mapped_column(DbEnum(Direction, native_enum=False), nullable=True)
+    building: Mapped[int] = mapped_column(String)
+    is_deleted: Mapped[int] = mapped_column(Boolean, default=False)
 
-    events: list[Event] = relationship(
+    events: Mapped[list[Event]] = relationship(
         "Event",
         back_populates="room",
         secondary="events_rooms",
@@ -48,34 +46,34 @@ class Room(BaseDbModel):
 
 
 class Lecturer(BaseDbModel):
-    first_name = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    middle_name = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    last_name = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    avatar_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("photo.id"))
-    description = sqlalchemy.Column(sqlalchemy.Text, nullable=True)
-    is_deleted = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
-
-    avatar: Photo = relationship(
+    first_name: Mapped[int] = mapped_column(String, nullable=False)
+    middle_name: Mapped[int] = mapped_column(String, nullable=False)
+    last_name: Mapped[int] = mapped_column(String, nullable=False)
+    avatar_id: Mapped[int] = mapped_column(Integer, ForeignKey("photo.id"))
+    description: Mapped[int] = mapped_column(Text, nullable=True)
+    is_deleted: Mapped[int] = mapped_column(Boolean, default=False)
+
+    avatar: Mapped[Photo] = relationship(
         "Photo",
         foreign_keys="Lecturer.avatar_id",
         backref="is_avatar_for",
         primaryjoin="and_(Lecturer.avatar_id==Photo.id, not_(Photo.is_deleted))",
     )
-    photos: list[Photo] = relationship(
+    photos: Mapped[list[Photo]] = relationship(
         "Photo",
         back_populates="lecturer",
         foreign_keys="Photo.lecturer_id",
         order_by="Photo.id",
         primaryjoin="and_(Lecturer.id==Photo.lecturer_id, not_(Photo.is_deleted), Photo.approve_status=='APPROVED')",
     )
-    events: list[Event] = relationship(
+    events: Mapped[list[Event]] = relationship(
         "Event",
         secondary="events_lecturers",
         order_by="(Event.start_ts)",
         back_populates="lecturer",
         secondaryjoin="and_(Event.id==EventsLecturers.event_id, not_(Event.is_deleted))",
     )
-    comments: list[CommentLecturer] = relationship(
+    comments: Mapped[list[CommentLecturer]] = relationship(
         "CommentLecturer",
         back_populates="lecturer",
         foreign_keys="CommentLecturer.lecturer_id",
@@ -84,7 +82,7 @@ class Lecturer(BaseDbModel):
 
     @hybrid_method
     def search(self, query: str) -> bool:
-        response = sqlalchemy.true
+        response = true
         query = query.split(' ')
         for q in query:
             response = and_(
@@ -98,11 +96,11 @@ def last_photo(self) -> Photo | None:
 
 
 class Group(BaseDbModel):
-    name = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    number = sqlalchemy.Column(sqlalchemy.String, nullable=False, unique=True)
-    is_deleted = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
+    name: Mapped[int] = mapped_column(String, nullable=False)
+    number: Mapped[int] = mapped_column(String, nullable=False, unique=True)
+    is_deleted: Mapped[int] = mapped_column(Boolean, default=False)
 
-    events: list[Event] = relationship(
+    events: Mapped[list[Event]] = relationship(
         "Event",
         foreign_keys="Event.group_id",
         order_by="(Event.start_ts)",
@@ -111,31 +109,31 @@ class Group(BaseDbModel):
 
 
 class Event(BaseDbModel):
-    name = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    group_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("group.id"))
-    start_ts = sqlalchemy.Column(sqlalchemy.DateTime, nullable=False)
-    end_ts = sqlalchemy.Column(sqlalchemy.DateTime, nullable=False)
-    is_deleted = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
+    name: Mapped[int] = mapped_column(String, nullable=False)
+    group_id: Mapped[int] = mapped_column(Integer, ForeignKey("group.id"))
+    start_ts: Mapped[int] = mapped_column(DateTime, nullable=False)
+    end_ts: Mapped[int] = mapped_column(DateTime, nullable=False)
+    is_deleted: Mapped[int] = mapped_column(Boolean, default=False)
 
-    room: list[Room] = relationship(
+    room: Mapped[list[Room]] = relationship(
         "Room",
         back_populates="events",
         secondary="events_rooms",
         secondaryjoin="and_(Room.id==EventsRooms.room_id, not_(Room.is_deleted))",
     )
-    group: Group = relationship(
+    group: Mapped[Group] = relationship(
         "Group",
         back_populates="events",
         foreign_keys="Event.group_id",
         primaryjoin="and_(Group.id==Event.group_id, not_(Group.is_deleted))",
     )
-    lecturer: list[Lecturer] = relationship(
+    lecturer: Mapped[list[Lecturer]] = relationship(
         "Lecturer",
         back_populates="events",
         secondary="events_lecturers",
         secondaryjoin="and_(Lecturer.id==EventsLecturers.lecturer_id, not_(Lecturer.is_deleted))",
     )
-    comments: list[CommentEvent] = relationship(
+    comments: Mapped[list[CommentEvent]] = relationship(
         "CommentEvent",
         foreign_keys="CommentEvent.event_id",
         back_populates="event",
@@ -144,22 +142,22 @@ class Event(BaseDbModel):
 
 
 class EventsLecturers(BaseDbModel):
-    event_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("event.id"))
-    lecturer_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("lecturer.id"))
+    event_id: Mapped[int] = mapped_column(Integer, ForeignKey("event.id"))
+    lecturer_id: Mapped[int] = mapped_column(Integer, ForeignKey("lecturer.id"))
 
 
 class EventsRooms(BaseDbModel):
-    event_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("event.id"))
-    room_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("room.id"))
+    event_id: Mapped[int] = mapped_column(Integer, ForeignKey("event.id"))
+    room_id: Mapped[int] = mapped_column(Integer, ForeignKey("room.id"))
 
 
 class Photo(BaseDbModel):
-    lecturer_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("lecturer.id"))
-    link = sqlalchemy.Column(sqlalchemy.String, unique=True)
-    approve_status = sqlalchemy.Column(DbEnum(ApproveStatuses, native_enum=False), nullable=False)
-    is_deleted = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
+    lecturer_id: Mapped[int] = mapped_column(Integer, ForeignKey("lecturer.id"))
+    link: Mapped[int] = mapped_column(String, unique=True)
+    approve_status: Mapped[int] = mapped_column(DbEnum(ApproveStatuses, native_enum=False), nullable=False)
+    is_deleted: Mapped[int] = mapped_column(Boolean, default=False)
 
-    lecturer: Lecturer = relationship(
+    lecturer: Mapped[Lecturer] = relationship(
         "Lecturer",
         back_populates="photos",
         foreign_keys="Photo.lecturer_id",
@@ -169,15 +167,15 @@ class Photo(BaseDbModel):
 
 
 class CommentLecturer(BaseDbModel):
-    lecturer_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("lecturer.id"))
-    author_name = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    text = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    approve_status = sqlalchemy.Column(DbEnum(ApproveStatuses, native_enum=False), nullable=False)
-    create_ts = sqlalchemy.Column(sqlalchemy.DateTime, default=datetime.utcnow())
-    update_ts = sqlalchemy.Column(sqlalchemy.DateTime, default=datetime.utcnow(), onupdate=datetime.utcnow())
-    is_deleted = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
-
-    lecturer: Lecturer = relationship(
+    lecturer_id: Mapped[int] = mapped_column(Integer, ForeignKey("lecturer.id"))
+    author_name: Mapped[int] = mapped_column(String, nullable=False)
+    text: Mapped[int] = mapped_column(String, nullable=False)
+    approve_status: Mapped[int] = mapped_column(DbEnum(ApproveStatuses, native_enum=False), nullable=False)
+    create_ts: Mapped[int] = mapped_column(DateTime, default=datetime.utcnow())
+    update_ts: Mapped[int] = mapped_column(DateTime, default=datetime.utcnow(), onupdate=datetime.utcnow())
+    is_deleted: Mapped[int] = mapped_column(Boolean, default=False)
+
+    lecturer: Mapped[Lecturer] = relationship(
         "Lecturer",
         back_populates="comments",
         foreign_keys="CommentLecturer.lecturer_id",
@@ -186,15 +184,15 @@ class CommentLecturer(BaseDbModel):
 
 
 class CommentEvent(BaseDbModel):
-    event_id = sqlalchemy.Column(sqlalchemy.Integer, sqlalchemy.ForeignKey("event.id"))
-    author_name = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    text = sqlalchemy.Column(sqlalchemy.String, nullable=False)
-    approve_status = sqlalchemy.Column(DbEnum(ApproveStatuses, native_enum=False), nullable=False)
-    create_ts = sqlalchemy.Column(sqlalchemy.DateTime, default=datetime.utcnow())
-    update_ts = sqlalchemy.Column(sqlalchemy.DateTime, default=datetime.utcnow(), onupdate=datetime.utcnow())
-    is_deleted = sqlalchemy.Column(sqlalchemy.Boolean, default=False)
-
-    event: Event = relationship(
+    event_id: Mapped[int] = mapped_column(Integer, ForeignKey("event.id"))
+    author_name: Mapped[int] = mapped_column(String, nullable=False)
+    text: Mapped[int] = mapped_column(String, nullable=False)
+    approve_status: Mapped[int] = mapped_column(DbEnum(ApproveStatuses, native_enum=False), nullable=False)
+    create_ts: Mapped[int] = mapped_column(DateTime, default=datetime.utcnow())
+    update_ts: Mapped[int] = mapped_column(DateTime, default=datetime.utcnow(), onupdate=datetime.utcnow())
+    is_deleted: Mapped[int] = mapped_column(Boolean, default=False)
+
+    event: Mapped[Event] = relationship(
         "Event",
         back_populates="comments",
         foreign_keys="CommentEvent.event_id",

calendar_backend/routes/base.py

@@ -99,7 +99,6 @@ async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -
 app.add_middleware(
     DBSessionMiddleware,
     db_url=settings.DB_DSN,
-    session_args={"autocommit": True},
     engine_args={"pool_pre_ping": True},
 )
 app.add_middleware(

calendar_backend/routes/event/comment.py

@@ -22,8 +22,10 @@
 @event_comment_router.post("/comment/", response_model=CommentEventGet)
 async def comment_event(event_id: int, comment: EventCommentPost) -> CommentEventGet:
     approve_status = ApproveStatuses.APPROVED if not settings.REQUIRE_REVIEW_EVENT_COMMENT else ApproveStatuses.PENDING
+    comment_event = DbCommentEvent.create(event_id=event_id, session=db.session, **comment.dict(), approve_status=approve_status)
+    db.session.commit()
     return CommentEventGet.from_orm(
-        DbCommentEvent.create(event_id=event_id, session=db.session, **comment.dict(), approve_status=approve_status)
+        comment_event
     )
 
 
@@ -34,8 +36,10 @@ async def update_comment(id: int, event_id: int, comment_inp: EventCommentPatch)
         raise ObjectNotFound(DbCommentEvent, id)
     if comment.approve_status is not ApproveStatuses.PENDING:
         raise ForbiddenAction(DbCommentEvent, id)
+    comment_event = DbCommentEvent.update(id, session=db.session, **comment_inp.dict(exclude_unset=True))
+    db.session.commit()
     return CommentEventGet.from_orm(
-        DbCommentEvent.update(id, session=db.session, **comment_inp.dict(exclude_unset=True))
+        comment_event
     )
 
 
@@ -52,7 +56,9 @@ async def delete_comment(id: int, event_id: int, _: auth.User = Depends(auth.get
     comment = DbCommentEvent.get(id, only_approved=False, session=db.session)
     if comment.event_id != event_id or comment.approve_status != ApproveStatuses.APPROVED:
         raise ObjectNotFound(DbCommentEvent, id)
-    return DbCommentEvent.delete(id=id, session=db.session)
+    DbCommentEvent.delete(id=id, session=db.session)
+    db.session.commit()
+    return None
 
 
 @event_comment_router.get("/comment/", response_model=EventComments)

calendar_backend/routes/event/comment_review.py

@@ -42,5 +42,5 @@ async def review_comment(
     DbCommentEvent.update(comment.id, approve_status=action, session=db.session)
     if action == ApproveStatuses.DECLINED:
         DbCommentEvent.delete(comment.id, session=db.session)
-    db.session.flush()
+    db.session.commit()
     return CommentEventGet.from_orm(comment)

calendar_backend/routes/event/event.py

@@ -91,14 +91,16 @@ async def create_event(event: EventPost, _: auth.User = Depends(auth.get_current
     rooms = [Room.get(room_id, session=db.session) for room_id in event_dict.pop("room_id", [])]
     lecturers = [Lecturer.get(lecturer_id, session=db.session) for lecturer_id in event_dict.pop("lecturer_id", [])]
     group = Group.get(event.group_id, session=db.session)
-    return EventGet.from_orm(
-        Event.create(
+    event_get = Event.create(
             **event_dict,
             room=rooms,
             lecturer=lecturers,
             group=group,
             session=db.session,
         )
+    db.session.commit()
+    return EventGet.from_orm(
+        event_get
     )
 
 
@@ -119,21 +121,26 @@ async def create_events(events: list[EventPost], _: auth.User = Depends(auth.get
                 session=db.session,
             )
         )
+    db.session.commit()
     return parse_obj_as(list[EventGet], result)
 
 
 @event_router.patch("/{id}", response_model=EventGet)
 async def patch_event(id: int, event_inp: EventPatch, _: auth.User = Depends(auth.get_current_user)) -> EventGet:
-    return EventGet.from_orm(Event.update(id, session=db.session, **event_inp.dict(exclude_unset=True)))
+    patched = Event.update(id, session=db.session, **event_inp.dict(exclude_unset=True))
+    db.session.commit()
+    return EventGet.from_orm(patched)
 
 
 @event_router.delete("/bulk", response_model=None)
 async def delete_events(start: date, end: date, _: auth.User = Depends(auth.get_current_user)) -> None:
     db.session.query(Event).filter(Event.start_ts >= start, Event.end_ts < end).update(
         values={"is_deleted": True}
     )
+    db.session.commit()
 
 
 @event_router.delete("/{id}", response_model=None)
 async def delete_event(id: int, _: auth.User = Depends(auth.get_current_user)) -> None:
     Event.delete(id, session=db.session)
+    db.session.commit()

calendar_backend/routes/group/group.py

@@ -39,7 +39,9 @@ async def get_groups(query: str = "", limit: int = 10, offset: int = 0) -> GetLi
 async def create_group(group: GroupPost, _: auth.User = Depends(auth.get_current_user)) -> GroupGet:
     if db.session.query(Group).filter(Group.number == group.number).one_or_none():
         raise HTTPException(status_code=423, detail="Already exists")
-    return GroupGet.from_orm(Group.create(**group.dict(), session=db.session))
+    group = Group.create(**group.dict(), session=db.session)
+    db.session.commit()
+    return GroupGet.from_orm(group)
 
 
 @group_router.patch("/{id}", response_model=GroupGet)
@@ -53,9 +55,12 @@ async def patch_group(
             query.id != id
     ):
         raise HTTPException(status_code=423, detail="Already exists")
-    return GroupGet.from_orm(Group.update(id, **group_inp.dict(exclude_unset=True), session=db.session))
+    patched = Group.update(id, **group_inp.dict(exclude_unset=True), session=db.session)
+    db.session.commit()
+    return GroupGet.from_orm(patched)
 
 
 @group_router.delete("/{id}", response_model=None)
 async def delete_group(id: int, _: auth.User = Depends(auth.get_current_user)) -> None:
     Group.delete(id, session=db.session)
+    db.session.commit()