logdetective 2.0.1__py3-none-any.whl → 2.11.0__py3-none-any.whl

logdetective/server/database/models/merge_request_jobs.py

@@ -1,25 +1,30 @@
+from __future__ import annotations
 import enum
 import datetime
-from typing import Optional, List, Tuple, Self
+from typing import Optional, List, Tuple, Self, TYPE_CHECKING
 
 import backoff
 
 from sqlalchemy import (
     Enum,
-    Column,
     BigInteger,
     DateTime,
     String,
     ForeignKey,
     UniqueConstraint,
     desc,
+    select,
 )
-from sqlalchemy.orm import relationship
+from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.engine import Row
 from sqlalchemy.exc import OperationalError
 from logdetective.server.database.base import Base, transaction, DB_MAX_RETRIES
 
 
+if TYPE_CHECKING:
+    from .metrics import AnalyzeRequestMetrics
+
+
 class Forge(str, enum.Enum):
     """List of forges managed by logdetective"""
 
@@ -34,21 +39,26 @@ class GitlabMergeRequestJobs(Base):
 
     __tablename__ = "gitlab_merge_request_jobs"
 
-    id = Column(BigInteger, primary_key=True)
-    forge = Column(Enum(Forge), nullable=False, index=True, comment="The forge name")
-    project_id = Column(
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    forge: Mapped[Forge] = mapped_column(
+        Enum(Forge),
+        nullable=False,
+        index=True,
+        comment="The forge name"
+    )
+    project_id: Mapped[int] = mapped_column(
         BigInteger,
         nullable=False,
         index=True,
         comment="The project gitlab id",
     )
-    mr_iid = Column(
+    mr_iid: Mapped[int] = mapped_column(
         BigInteger,
         nullable=False,
         index=False,
         comment="The merge request gitlab iid",
     )
-    job_id = Column(
+    job_id: Mapped[int] = mapped_column(
         BigInteger,
         nullable=False,
         index=True,
@@ -62,15 +72,18 @@ class GitlabMergeRequestJobs(Base):
         ),
     )
 
-    comment = relationship(
+    comment: Mapped[List["Comments"]] = relationship(
         "Comments", back_populates="merge_request_job", uselist=False
     )  # 1 comment for 1 job
 
-    request_metrics = relationship("AnalyzeRequestMetrics", back_populates="mr_job")
+    request_metrics: Mapped[List["AnalyzeRequestMetrics"]] = relationship(
+        "AnalyzeRequestMetrics",
+        back_populates="mr_job"
+    )
 
     @classmethod
     @backoff.on_exception(backoff.expo, OperationalError, max_tries=DB_MAX_RETRIES)
-    def create(
+    async def create(
         cls,
         forge: Forge,
         project_id: int,
@@ -86,28 +99,30 @@ class GitlabMergeRequestJobs(Base):
           mr_iid: merge request forge iid
           job_id: forge job id
         """
-        with transaction(commit=True) as session:
+        async with transaction(commit=True) as session:
             mr = cls()
             mr.forge = forge
             mr.project_id = project_id
             mr.mr_iid = mr_iid
             mr.job_id = job_id
             session.add(mr)
-            session.flush()
+            await session.flush()
             return mr.id
 
     @classmethod
-    def get_by_id(
+    async def get_by_id(
         cls,
         id_: int,
     ) -> Optional["GitlabMergeRequestJobs"]:
         """Search for a given PostgreSQL id"""
-        with transaction(commit=False) as session:
-            mr = session.query(cls).filter_by(id=id_).first()
+        query = select(cls).where(cls.id == id_)
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            mr = query_result.scalars().first()
             return mr
 
     @classmethod
-    def get_by_details(
+    async def get_by_details(
         cls,
         forge: Forge,
         project_id: int,
@@ -122,36 +137,34 @@ class GitlabMergeRequestJobs(Base):
           mr_iid: merge request forge iid
           job_id: forge job id
         """
-        with transaction(commit=False) as session:
-            mr = (
-                session.query(cls)
-                .filter_by(
-                    forge=forge, project_id=project_id, mr_iid=mr_iid, job_id=job_id
-                )
-                .first()
-            )
+        query = select(cls).where(
+            cls.forge == forge,
+            cls.project_id == project_id,
+            cls.mr_iid == mr_iid,
+            cls.job_id == job_id,
+        )
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            mr = query_result.scalars().first()
             return mr
 
     @classmethod
-    def get_by_mr_iid(
-        cls, forge: Forge, project_id: int, mr_iid
-    ) -> List[Self]:
+    async def get_by_mr_iid(cls, forge: Forge, project_id: int, mr_iid) -> List[Self]:
         """Get all the mr jobs saved for the specified mr iid and project id."""
-        with transaction(commit=False) as session:
-            comments = (
-                session.query(cls)
-                .filter(
-                    GitlabMergeRequestJobs.forge == forge,
-                    GitlabMergeRequestJobs.project_id == project_id,
-                    GitlabMergeRequestJobs.mr_iid == mr_iid,
-                )
-                .all()
-            )
+        query = select(cls).where(
+            GitlabMergeRequestJobs.forge == forge,
+            GitlabMergeRequestJobs.project_id == project_id,
+            GitlabMergeRequestJobs.mr_iid == mr_iid,
+        )
+
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            comments = query_result.scalars().all()
 
             return comments
 
     @classmethod
-    def get_or_create(
+    async def get_or_create(
         cls,
         forge: Forge,
         project_id: int,
@@ -167,10 +180,12 @@ class GitlabMergeRequestJobs(Base):
           mr_iid: merge request forge iid
           job_id: forge job id
         """
-        mr = GitlabMergeRequestJobs.get_by_details(forge, project_id, mr_iid, job_id)
+        mr = await GitlabMergeRequestJobs.get_by_details(
+            forge, project_id, mr_iid, job_id
+        )
         if mr is None:
-            id_ = GitlabMergeRequestJobs.create(forge, project_id, mr_iid, job_id)
-            mr = GitlabMergeRequestJobs.get_by_id(id_)
+            id_ = await GitlabMergeRequestJobs.create(forge, project_id, mr_iid, job_id)
+            mr = await GitlabMergeRequestJobs.get_by_id(id_)
         return mr
 
 
@@ -180,8 +195,8 @@ class Comments(Base):
 
     __tablename__ = "comments"
 
-    id = Column(BigInteger, primary_key=True)
-    merge_request_job_id = Column(
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    merge_request_job_id: Mapped[int] = mapped_column(
         BigInteger,
         ForeignKey("gitlab_merge_request_jobs.id"),
         nullable=False,
@@ -189,27 +204,37 @@ class Comments(Base):
         index=True,
         comment="The associated merge request job (db) id",
     )
-    forge = Column(Enum(Forge), nullable=False, index=True, comment="The forge name")
-    comment_id = Column(
+    forge: Mapped[Forge] = mapped_column(
+        Enum(Forge),
+        nullable=False,
+        index=True,
+        comment="The forge name"
+    )
+    comment_id: Mapped[str] = mapped_column(
         String(50),  # e.g. 'd5a3ff139356ce33e37e73add446f16869741b50'
         nullable=False,
         index=True,
         comment="The comment gitlab id",
     )
-    created_at = Column(
-        DateTime, nullable=False, comment="Timestamp when the comment was created"
+    created_at: Mapped[datetime.datetime] = mapped_column(
+        DateTime(timezone=True),
+        nullable=False,
+        comment="Timestamp when the comment was created",
     )
 
     __table_args__ = (
         UniqueConstraint("forge", "comment_id", name="uix_forge_comment_id"),
     )
 
-    merge_request_job = relationship("GitlabMergeRequestJobs", back_populates="comment")
-    reactions = relationship("Reactions", back_populates="comment")
+    merge_request_job: Mapped["GitlabMergeRequestJobs"] = relationship(
+        "GitlabMergeRequestJobs",
+        back_populates="comment"
+    )
+    reactions: Mapped[list["Reactions"]] = relationship("Reactions", back_populates="comment")
 
     @classmethod
     @backoff.on_exception(backoff.expo, OperationalError, max_tries=DB_MAX_RETRIES)
-    def create(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
+    async def create(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
         cls,
         forge: Forge,
         project_id: int,
@@ -230,8 +255,8 @@ class Comments(Base):
           job_id: forge job id
           comment_id: forge comment id
         """
-        with transaction(commit=True) as session:
-            mr_job = GitlabMergeRequestJobs.get_or_create(
+        async with transaction(commit=True) as session:
+            mr_job = await GitlabMergeRequestJobs.get_or_create(
                 forge, project_id, mr_iid, job_id
             )
 
@@ -245,21 +270,23 @@ class Comments(Base):
             comment.created_at = datetime.datetime.now(datetime.timezone.utc)
             comment.merge_request_job_id = mr_job.id
             session.add(comment)
-            session.flush()
+            await session.flush()
             return comment.id
 
     @classmethod
-    def get_by_id(
+    async def get_by_id(
         cls,
         id_: int,
     ) -> Optional["Comments"]:
         """Search for a given PostgreSQL id"""
-        with transaction(commit=False) as session:
-            comment = session.query(cls).filter_by(id=id_).first()
+        query = select(cls).where(cls.id == id_)
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            comment = query_result.scalars().first()
             return comment
 
     @classmethod
-    def get_by_gitlab_id(
+    async def get_by_gitlab_id(
         cls,
         forge: Forge,
         comment_id: str,
@@ -271,24 +298,21 @@ class Comments(Base):
           forge: forge name
           comment_id: forge comment id
         """
-        with transaction(commit=False) as session:
-            comment = (
-                session.query(cls)
-                .join(
-                    GitlabMergeRequestJobs,
-                    cls.merge_request_job_id == GitlabMergeRequestJobs.id,
-                )
-                .filter(
-                    GitlabMergeRequestJobs.forge == forge,
-                    cls.comment_id == comment_id,
-                )
-                .first()
+        query = (
+            select(cls)
+            .join(
+                GitlabMergeRequestJobs,
+                cls.merge_request_job_id == GitlabMergeRequestJobs.id,
             )
-
+            .filter(GitlabMergeRequestJobs.forge == forge, cls.comment_id == comment_id)
+        )
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            comment = query_result.scalars().first()
             return comment
 
     @classmethod
-    def get_latest_comment(
+    async def get_latest_comment(
         cls,
         forge: Forge,
         project_id: int,
@@ -301,26 +325,26 @@ class Comments(Base):
           project_id: forge project id
           mr_iid: merge request forge iid
         """
-        with transaction(commit=False) as session:
-            comment = (
-                session.query(cls)
-                .join(
-                    GitlabMergeRequestJobs,
-                    cls.merge_request_job_id == GitlabMergeRequestJobs.id,
-                )
-                .filter(
-                    GitlabMergeRequestJobs.forge == forge,
-                    GitlabMergeRequestJobs.project_id == project_id,
-                    GitlabMergeRequestJobs.mr_iid == mr_iid,
-                )
-                .order_by(desc(cls.created_at))
-                .first()
+        query = (
+            select(cls)
+            .join(
+                GitlabMergeRequestJobs,
+                cls.merge_request_job_id == GitlabMergeRequestJobs.id,
             )
-
+            .filter(
+                GitlabMergeRequestJobs.forge == forge,
+                GitlabMergeRequestJobs.project_id == project_id,
+                GitlabMergeRequestJobs.mr_iid == mr_iid,
+            )
+            .order_by(desc(cls.created_at))
+        )
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            comment = query_result.scalars().first()
             return comment
 
     @classmethod
-    def get_mr_comments(
+    async def get_mr_comments(
         cls,
         forge: Forge,
         project_id: int,
@@ -333,26 +357,26 @@ class Comments(Base):
           project_id: forge project id
           mr_iid: merge request forge iid
         """
-        with transaction(commit=False) as session:
-            comments = (
-                session.query(cls)
-                .join(
-                    GitlabMergeRequestJobs,
-                    cls.merge_request_job_id == GitlabMergeRequestJobs.id,
-                )
-                .filter(
-                    GitlabMergeRequestJobs.forge == forge,
-                    GitlabMergeRequestJobs.project_id == project_id,
-                    GitlabMergeRequestJobs.mr_iid == mr_iid,
-                )
-                .order_by(desc(cls.created_at))
-                .all()
+        query = (
+            select(cls)
+            .join(
+                GitlabMergeRequestJobs,
+                cls.merge_request_job_id == GitlabMergeRequestJobs.id,
             )
-
+            .filter(
+                GitlabMergeRequestJobs.forge == forge,
+                GitlabMergeRequestJobs.project_id == project_id,
+                GitlabMergeRequestJobs.mr_iid == mr_iid,
+            )
+            .order_by(desc(cls.created_at))
+        )
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            comments = query_result.scalars().all()
             return comments
 
     @classmethod
-    def get_or_create(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
+    async def get_or_create(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
         cls,
         forge: Forge,
         project_id: int,
@@ -370,40 +394,31 @@ class Comments(Base):
           job_id: forge job id
           comment_id: forge comment id
         """
-        comment = Comments.get_by_gitlab_id(forge, comment_id)
+        comment = await Comments.get_by_gitlab_id(forge, comment_id)
         if comment is None:
-            id_ = Comments.create(forge, project_id, mr_iid, job_id, comment_id)
-            comment = Comments.get_by_id(id_)
+            id_ = await Comments.create(forge, project_id, mr_iid, job_id, comment_id)
+            comment = await Comments.get_by_id(id_)
         return comment
 
     @classmethod
-    def get_since(cls, time: datetime.datetime) -> List[Self]:
+    async def get_since(cls, time: datetime.datetime) -> List[Self]:
         """Get all the comments created after the given time."""
-        with transaction(commit=False) as session:
-            comments = (
-                session.query(cls)
-                .filter(
-                    Comments.created_at > time,
-                )
-                .all()
-            )
+        query = select(cls).filter(Comments.created_at > time)
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            comments = query_result.scalars().all()
 
             return comments
 
     @classmethod
-    def get_by_mr_job(
+    async def get_by_mr_job(
         cls, merge_request_job: GitlabMergeRequestJobs
     ) -> Optional["Comments"]:
         """Get the comment added for the specified merge request's job."""
-        with transaction(commit=False) as session:
-            comments = (
-                session.query(cls)
-                .filter(
-                    Comments.merge_request_job == merge_request_job,
-                )
-                .first()  # just one
-            )
-
+        query = select(cls).filter(Comments.merge_request_job == merge_request_job)
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            comments = query_result.scalars().first()
             return comments
 
 
@@ -413,20 +428,20 @@ class Reactions(Base):
 
     __tablename__ = "reactions"
 
-    id = Column(BigInteger, primary_key=True)
-    comment_id = Column(
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
+    comment_id: Mapped[int] = mapped_column(
         BigInteger,
         ForeignKey("comments.id"),
         nullable=False,
         index=True,
         comment="The associated comment (db) id",
     )
-    reaction_type = Column(
+    reaction_type: Mapped[str] = mapped_column(
         String(127),  # e.g. 'thumbs-up'
         nullable=False,
         comment="The type of reaction",
     )
-    count = Column(
+    count: Mapped[int] = mapped_column(
         BigInteger,
         nullable=False,
         comment="The number of reactions, of this type, given in the comment",
@@ -436,11 +451,11 @@ class Reactions(Base):
         UniqueConstraint("comment_id", "reaction_type", name="uix_comment_reaction"),
     )
 
-    comment = relationship("Comments", back_populates="reactions")
+    comment: Mapped["Comments"] = relationship("Comments", back_populates="reactions")
 
     @classmethod
     @backoff.on_exception(backoff.expo, OperationalError, max_tries=DB_MAX_RETRIES)
-    def create_or_update(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
+    async def create_or_update(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
         cls,
         forge: Forge,
         project_id: int,
@@ -462,11 +477,13 @@ class Reactions(Base):
           reaction_type: a str, ex. thumb_up
           count: number of reactions, of this type, given in the comment
         """
-        comment = Comments.get_or_create(forge, project_id, mr_iid, job_id, comment_id)
-        reaction = cls.get_reaction_by_type(
+        comment = await Comments.get_or_create(
+            forge, project_id, mr_iid, job_id, comment_id
+        )
+        reaction = await cls.get_reaction_by_type(
             forge, project_id, mr_iid, job_id, comment_id, reaction_type
         )
-        with transaction(commit=True) as session:
+        async with transaction(commit=True) as session:
             if reaction:
                 reaction.count = count  # just update
             else:
@@ -475,11 +492,11 @@ class Reactions(Base):
                 reaction.reaction_type = reaction_type
                 reaction.count = count
             session.add(reaction)
-            session.flush()
+            await session.flush()
             return reaction.id
 
     @classmethod
-    def get_all_reactions(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
+    async def get_all_reactions(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
         cls,
         forge: Forge,
         project_id: int,
@@ -496,28 +513,28 @@ class Reactions(Base):
           job_id: forge job id
           comment_id: forge comment id
         """
-        with transaction(commit=False) as session:
-            reactions = (
-                session.query(cls)
-                .join(Comments, cls.comment_id == Comments.id)
-                .join(
-                    GitlabMergeRequestJobs,
-                    Comments.merge_request_job_id == GitlabMergeRequestJobs.id,
-                )
-                .filter(
-                    Comments.comment_id == comment_id,
-                    GitlabMergeRequestJobs.forge == forge,
-                    GitlabMergeRequestJobs.project_id == project_id,
-                    GitlabMergeRequestJobs.mr_iid == mr_iid,
-                    GitlabMergeRequestJobs.job_id == job_id,
-                )
-                .all()
+        query = (
+            select(cls)
+            .join(Comments, cls.comment_id == Comments.id)
+            .join(
+                GitlabMergeRequestJobs,
+                Comments.merge_request_job_id == GitlabMergeRequestJobs.id,
             )
-
+            .filter(
+                Comments.comment_id == comment_id,
+                GitlabMergeRequestJobs.forge == forge,
+                GitlabMergeRequestJobs.project_id == project_id,
+                GitlabMergeRequestJobs.mr_iid == mr_iid,
+                GitlabMergeRequestJobs.job_id == job_id,
+            )
+        )
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            reactions = query_result.scalars().all()
             return reactions
 
     @classmethod
-    def get_reaction_by_type(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
+    async def get_reaction_by_type(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
         cls,
         forge: Forge,
         project_id: int,
@@ -537,30 +554,30 @@ class Reactions(Base):
           comment_id: forge comment id
           reaction_type: str like "thumb-up"
         """
-        with transaction(commit=False) as session:
-            reaction = (
-                session.query(cls)
-                .join(Comments, cls.comment_id == Comments.id)
-                .join(
-                    GitlabMergeRequestJobs,
-                    Comments.merge_request_job_id == GitlabMergeRequestJobs.id,
-                )
-                .filter(
-                    Comments.comment_id == comment_id,
-                    GitlabMergeRequestJobs.forge == forge,
-                    GitlabMergeRequestJobs.project_id == project_id,
-                    GitlabMergeRequestJobs.mr_iid == mr_iid,
-                    GitlabMergeRequestJobs.job_id == job_id,
-                    Reactions.reaction_type == reaction_type,
-                )
-                .first()
+        query = (
+            select(cls)
+            .join(Comments, cls.comment_id == Comments.id)
+            .join(
+                GitlabMergeRequestJobs,
+                Comments.merge_request_job_id == GitlabMergeRequestJobs.id,
             )
-
+            .filter(
+                Comments.comment_id == comment_id,
+                GitlabMergeRequestJobs.forge == forge,
+                GitlabMergeRequestJobs.project_id == project_id,
+                GitlabMergeRequestJobs.mr_iid == mr_iid,
+                GitlabMergeRequestJobs.job_id == job_id,
+                Reactions.reaction_type == reaction_type,
+            )
+        )
+        async with transaction(commit=False) as session:
+            query_result = await session.execute(query)
+            reaction = query_result.scalars().first()
             return reaction
 
     @classmethod
     @backoff.on_exception(backoff.expo, OperationalError, max_tries=DB_MAX_RETRIES)
-    def delete(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
+    async def delete(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
         cls,
         forge: Forge,
         project_id: int,
@@ -580,25 +597,27 @@ class Reactions(Base):
           reaction_type: a str iterable, ex. ['thumbsup', 'thumbsdown']
         """
         for reaction_type in reaction_types:
-            reaction = cls.get_reaction_by_type(
+            reaction = await cls.get_reaction_by_type(
                 forge, project_id, mr_iid, job_id, comment_id, reaction_type
             )
-            with transaction(commit=True) as session:
-                session.delete(reaction)
-                session.flush()
+            async with transaction(commit=True) as session:
+                await session.delete(reaction)
+                await session.flush()
 
     @classmethod
-    def get_since(
+    async def get_since(
         cls, time: datetime.datetime
     ) -> List[Row[Tuple[datetime.datetime, Self]]]:
         """Get all the reactions on comments created after the given time
         and the comment creation time."""
-        with transaction(commit=False) as session:
-            reactions = (
-                session.query(Comments.created_at, cls)
-                .join(Comments, cls.comment_id == Comments.id)
-                .filter(Comments.created_at > time)
-                .all()
-            )
+        query = (
+            select(Comments.created_at, cls)
+            .join(Comments, cls.comment_id == Comments.id)
+            .filter(Comments.created_at > time)
+        )
+
+        async with transaction(commit=False) as session:
+            query_results = await session.execute(query)
+            reactions = query_results.all()
 
             return reactions