builders: Migrate to SQLModel

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/buildservice/builders.py b/src/buildservice/builders.py
index 36781aa7883aeb84834b328b1f9f8bcd105c3204..90e804887e66a9ed707c66e186d426d5e6ebc2a3 100644 (file)
--- a/src/buildservice/builders.py
+++ b/src/buildservice/builders.py
@@ -6,9 +6,9 @@ import datetime
 import functools
 import json
 import logging
-
 import sqlalchemy
-from sqlalchemy import BigInteger, Boolean, Column, DateTime, Double, ForeignKey, Integer, Text
+import sqlmodel
+
 from sqlalchemy.dialects.postgresql import INET
 
 from . import base
@@ -22,63 +22,62 @@ from .errors import *
 # Setup logging
 log = logging.getLogger("pbs.builders")
 
-class BuilderStat(database.Base):
+class BuilderStat(sqlmodel.SQLModel, table=True):
        __tablename__ = "builder_stats"
 
        # Builder ID
 
-       builder_id = Column(Integer, ForeignKey("builders.id"), primary_key=True, nullable=False)
+       builder_id : int = sqlmodel.Field(foreign_key="builders.id", primary_key=True)
 
        # Builder
 
-       builder = sqlalchemy.orm.relationship(
-               "Builder", foreign_keys=[builder_id], lazy="joined", innerjoin=True,
-       )
+       builder : "Builder" = sqlmodel.Relationship()
 
        # Created At
 
-       created_at = Column(DateTime(timezone=False), primary_key=True, nullable=False,
-               server_default=sqlalchemy.func.current_timestamp())
+       created_at : datetime.datetime = sqlmodel.Field(
+               sa_column_kwargs = {"server_default" : sqlalchemy.text("CURRENT_TIMESTAMP")}
+       )
 
        # CPU User
 
-       cpu_user = Column(Double, nullable=False)
+       cpu_user : float
 
        # CPU Nice
 
-       cpu_nice = Column(Double, nullable=False)
+       cpu_nice : float
 
        # CPU System
 
-       cpu_system = Column(Double, nullable=False)
+       cpu_system : float
 
        # CPU Idle
 
-       cpu_idle = Column(Double, nullable=False)
+       cpu_idle : float
 
        # CPU IO Wait
 
-       cpu_iowait = Column(Double, nullable=False)
+       cpu_iowait : float
 
        # CPU IRQ
 
-       cpu_irq = Column(Double, nullable=False)
+       cpu_irq : float
 
        # CPU Soft IRQ
 
-       cpu_softirq = Column(Double, nullable=False)
+       cpu_softirq : float
 
        # CPU Steal
 
-       cpu_steal = Column(Double, nullable=False)
+       cpu_steal : float
 
        # CPU Guest
 
-       cpu_guest = Column(Double, nullable=False)
+       cpu_guest : float
 
        # CPU Guest Nice
 
-       cpu_guest_nice = Column(Double, nullable=False)
+       cpu_guest_nice : float
 
        @property
        def cpu_usage(self):
@@ -89,51 +88,60 @@ class BuilderStat(database.Base):
 
        # Load Average 1
 
-       loadavg1 = Column(Double, nullable=False)
+       loadavg1 : float
 
        # Load Average 5
 
-       loadavg5 = Column(Double, nullable=False)
+       loadavg5 : float
 
        # Load Average 15
 
-       loadavg15 = Column(Double, nullable=False)
+       loadavg15 : float
 
        # Memory Total
 
-       mem_total = Column(BigInteger, nullable=False)
+       mem_total : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Memory Available
 
-       mem_available = Column(BigInteger, nullable=False)
+       mem_available : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Memory Used
 
-       mem_used = Column(BigInteger, nullable=False)
+       mem_used : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Memory Free
 
-       mem_free = Column(BigInteger, nullable=False)
+       mem_free : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Memory Active
 
-       mem_active = Column(BigInteger, nullable=False)
+       mem_active : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Memory Inactive
 
-       mem_inactive = Column(BigInteger, nullable=False)
+       mem_inactive : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Memory Buffers
 
-       mem_buffers = Column(BigInteger, nullable=False)
+       mem_buffers : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Memory Cached
 
-       mem_cached = Column(BigInteger, nullable=False)
+       mem_cached : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Memory Shared
 
-       mem_shared = Column(BigInteger, nullable=False)
+       mem_shared : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        @property
        def mem_usage(self):
@@ -144,15 +152,18 @@ class BuilderStat(database.Base):
 
        # Swap Total
 
-       swap_total = Column(BigInteger, nullable=False)
+       swap_total : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Swap Used
 
-       swap_used = Column(BigInteger, nullable=False)
+       swap_used : int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        # Swap Free
 
-       swap_free = Column(BigInteger, nullable=False)
+       swap_free: int = sqlmodel.Field(
+               sa_column=sqlalchemy.Column(sqlalchemy.BigInteger, nullable=False))
 
        @property
        def swap_usage(self):
@@ -438,7 +449,7 @@ class BuildersStats(base.Object):
                                )
 
 
-class Builder(database.Base, database.BackendMixin, database.SoftDeleteMixin):
+class Builder(sqlmodel.SQLModel, database.BackendMixin, database.SoftDeleteMixin, table=True):
        __tablename__ = "builders"
 
        def __lt__(self, other):
@@ -452,36 +463,35 @@ class Builder(database.Base, database.BackendMixin, database.SoftDeleteMixin):
 
        # ID
 
-       id = Column(Integer, primary_key=True)
+       id : int = sqlmodel.Field(primary_key=True)
 
        # Description
 
-       description = Column(Text, nullable=False, default="")
+       description : str = sqlmodel.Field(default="")
 
        # Created At
 
-       created_at = Column(DateTime(timezone=False), nullable=False,
-               server_default=sqlalchemy.func.current_timestamp())
+       created_at : datetime.datetime = sqlmodel.Field(
+               sa_column_kwargs = {"server_default" : sqlalchemy.text("CURRENT_TIMESTAMP")}
+       )
 
        # Created By ID
 
-       created_by_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+       created_by_id : int = sqlmodel.Field(foreign_key="users.id", exclude=True)
 
        # Created By
 
-       created_by = sqlalchemy.orm.relationship(
-               "User", foreign_keys=[created_by_id], lazy="joined", innerjoin=True,
-       )
+       created_by : "User" = sqlmodel.Relationship(
+               sa_relationship_kwargs={ "foreign_keys" : "[Builder.created_by_id]" })
 
        # Deleted By ID
 
-       deleted_by_id = Column(Integer, ForeignKey("users.id"))
+       deleted_by_id : int = sqlmodel.Field(foreign_key="users.id", exclude=True)
 
        # Deleted By
 
-       deleted_by = sqlalchemy.orm.relationship(
-               "User", foreign_keys=[deleted_by_id], lazy="selectin",
-       )
+       deleted_by : "User" = sqlmodel.Relationship(
+               sa_relationship_kwargs={ "foreign_keys" : "[Builder.deleted_by_id]" })
 
        def is_online(self):
                """
@@ -494,11 +504,11 @@ class Builder(database.Base, database.BackendMixin, database.SoftDeleteMixin):
 
        # Maintenance
 
-       maintenance = Column(Boolean, nullable=False, default=False)
+       maintenance : bool = sqlmodel.Field(default=False)
 
        # Enabled
 
-       enabled = Column(Boolean, nullable=False, default=False)
+       enabled : bool = sqlmodel.Field(default=False)
 
        # Permissions
 
@@ -579,7 +589,7 @@ class Builder(database.Base, database.BackendMixin, database.SoftDeleteMixin):
 
        # Max Jobs
 
-       max_jobs = Column(Integer, nullable=False, default=1)
+       max_jobs : int = sqlmodel.Field(default=1)
 
        async def is_full(self):
                """
@@ -595,43 +605,43 @@ class Builder(database.Base, database.BackendMixin, database.SoftDeleteMixin):
 
        # Name
 
-       name = Column(Text, unique=True, nullable=False)
+       name : str = sqlmodel.Field(unique=True)
 
        # (Pakfire) Version
 
-       version = Column(Text, nullable=False, default="")
+       version : str = sqlmodel.Field(default="")
 
        # OS Name
 
-       os_name = Column(Text, nullable=False, default="")
+       os_name : str = sqlmodel.Field(default="")
 
        # System Vendor
 
-       sys_vendor = Column(Text)
+       sys_vendor : str | None
 
        # System Name
 
-       sys_name = Column(Text)
+       sys_name : str | None
 
        # CPU Model
 
-       cpu_model = Column(Text, nullable=False, default="")
+       cpu_model : str = sqlmodel.Field(default="")
 
        # CPU Count
 
-       cpu_count = Column(Integer, nullable=False, default=1)
+       cpu_count : int = sqlmodel.Field(default=1)
 
        # Architecture
 
-       arch = Column(Text)
+       arch : str
 
        # AWS - Instance ID
 
-       instance_id = Column(Text)
+       instance_id : str
 
        # AWS - Instance Type
 
-       instance_type = Column(Text)
+       instance_type : str
 
        @functools.cached_property
        def instance(self):
@@ -903,11 +913,11 @@ class Builder(database.Base, database.BackendMixin, database.SoftDeleteMixin):
 
        # Connected At
 
-       connected_at = Column(DateTime(timezone=False))
+       connected_at : datetime.datetime | None
 
        # Connected From
 
-       connected_from = Column(INET)
+       connected_from : str | None = sqlmodel.Field(default=None, sa_column=sqlalchemy.Column(INET))
 
        # Send Message
 
@@ -938,7 +948,7 @@ class Builder(database.Base, database.BackendMixin, database.SoftDeleteMixin):
                        Returns all uploads that belong to this builder
                """
                stmt = (
-                       sqlalchemy
+                       sqlmodel
                        .select(uploads.Upload)
                        .where(
                                uploads.Upload.builder == self,