artemis-model 0.1.66__py3-none-any.whl

artemis_model/__init__.py

@@ -0,0 +1,17 @@
+from artemis_model.album import *  # noqa
+from artemis_model.artist import *  # noqa
+from artemis_model.auth import *  # noqa
+from artemis_model.category import *  # noqa
+from artemis_model.dj_set import *  # noqa
+from artemis_model.genre import *  # noqa
+from artemis_model.location import *  # noqa
+from artemis_model.message import *  # noqa
+from artemis_model.organization import *  # noqa
+from artemis_model.playlist import *  # noqa
+from artemis_model.schedule import *  # noqa
+from artemis_model.setting import *  # noqa
+from artemis_model.track import *  # noqa
+from artemis_model.user import *  # noqa
+from artemis_model.zone import *  # noqa
+from artemis_model.otp import *  # noqa
+

artemis_model/album.py

@@ -0,0 +1,73 @@
+"""Album models"""
+
+from datetime import datetime
+
+from sqlalchemy import Computed, ForeignKey, func, literal, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import CustomSyncBase, CustomBase, TSVector, TimeStampMixin
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+def to_tsvector_ix(*columns):
+    s = " || ' ' || ".join(columns)
+    return func.to_tsvector(literal("english"), text(s))
+
+
+class AlbumMixin(TimeStampMixin):
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    description: Mapped[str | None] = mapped_column(nullable=True)
+    entry_date: Mapped[datetime] = mapped_column(
+        nullable=False, default=datetime.utcnow
+    )
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+    legacy_id: Mapped[str] = mapped_column(nullable=False)
+    is_internal: Mapped[bool] = mapped_column(nullable=False, default=False)
+
+    name_tsv = mapped_column(
+        TSVector(),
+        Computed("to_tsvector('english', name)", persisted=True),
+    )
+
+    # __table_args__ = (
+    #     Index("fts_ix_album_name_tsv", to_tsvector_ix("name"), postgresql_using="gin"),
+    # )
+
+    @declared_attr
+    def artists(cls) -> Mapped[list["Artist"]]:
+        return relationship(secondary="album_artist_assoc", back_populates="albums")
+
+    @declared_attr
+    def tracks(cls) -> Mapped[list["Track"]]:
+        return relationship(
+            "Track",
+            back_populates="album",
+            cascade="all, delete-orphan",
+    )
+
+
+class AlbumSync(CustomSyncBase, AlbumMixin):
+    pass
+
+
+class Album(CustomBase, AlbumMixin):
+    pass
+
+
+class AlbumArtistAssocMixin():
+    album_id: Mapped[int] = mapped_column(
+        ForeignKey("album.id"), primary_key=True, nullable=False
+    )
+    artist_id: Mapped[int] = mapped_column(
+        ForeignKey("artist.id"), primary_key=True, nullable=False
+    )
+
+
+class AlbumArtistAssocSync(CustomSyncBase, AlbumArtistAssocMixin):
+    pass
+
+
+class AlbumArtistAssoc(CustomBase, AlbumArtistAssocMixin):
+    pass

artemis_model/artist.py

@@ -0,0 +1,51 @@
+"""Artist models"""
+
+from datetime import datetime
+
+from sqlalchemy import Computed, func, literal, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import CustomBase, CustomSyncBase, TSVector, TimeStampMixin
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+def to_tsvector_ix(*columns):
+    s = " || ' ' || ".join(columns)
+    return func.to_tsvector(literal("english"), text(s))
+
+
+class ArtistMixin(TimeStampMixin):
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    entry_date: Mapped[datetime] = mapped_column(
+        nullable=False, default=datetime.utcnow
+    )
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+    is_internal: Mapped[bool] = mapped_column(nullable=False, default=False)
+    legacy_id: Mapped[str] = mapped_column(nullable=False)
+
+    name_tsv = mapped_column(
+        TSVector(),
+        Computed("to_tsvector('english', name)", persisted=True),
+    )
+
+    # __table_args__ = (
+    #     Index("fts_ix_artist_name_tsv", to_tsvector_ix("name"), postgresql_using="gin"),
+    # )
+
+    @declared_attr
+    def albums(cls) -> Mapped[list["Album"]]:
+        return relationship(secondary="album_artist_assoc", back_populates="artists")
+
+    @declared_attr
+    def tracks(cls) -> Mapped[list["Track"]]:
+        return relationship("Track", back_populates="artist", cascade="all, delete-orphan")
+
+
+class ArtistSync(CustomSyncBase, ArtistMixin):
+    pass
+
+
+class Artist(CustomBase, ArtistMixin):
+    pass

artemis_model/auth.py

@@ -0,0 +1,119 @@
+"""Auth models."""
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import UUID, DateTime, ForeignKey, LargeBinary
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.ext.declarative import declared_attr
+
+from artemis_model.base import CustomSyncBase, TimeStampMixin, CustomBase
+
+
+class UserUnverifiedAccountMixin(TimeStampMixin):
+    """
+    This table is used to store the account info of users who have requested an account but have not yet
+    been verified. Once the user has been verified, the account will be moved to the UserAccount table.
+    """
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    email: Mapped[str] = mapped_column(index=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    mobile: Mapped[str] = mapped_column(nullable=True, index=True)
+    is_root_user: Mapped[bool] = mapped_column(default=True)
+    is_email_verified: Mapped[bool] = mapped_column(default=False)
+    is_mobile_verified: Mapped[bool] = mapped_column(default=False)
+    is_onboarded: Mapped[bool] = mapped_column(default=False)
+    password = mapped_column(LargeBinary, nullable=False)
+    provider: Mapped[str] = mapped_column(default="internal")
+
+
+class UserUnverifiedAccountSync(CustomSyncBase, UserUnverifiedAccountMixin):
+    pass
+
+
+class UserUnverifiedAccount(CustomBase, UserUnverifiedAccountMixin):
+    pass
+
+
+class UserAccountMixin(TimeStampMixin):
+    """
+    This table is used to store the account info of users who have been verified.
+    """
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    email: Mapped[str] = mapped_column(index=True, unique=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    mobile: Mapped[Optional[str]] = mapped_column(
+        nullable=True, unique=True, index=True
+    )
+    password = mapped_column(LargeBinary, nullable=True)
+    provider: Mapped[str] = mapped_column(nullable=False)
+    oauth_id: Mapped[Optional[str]] = mapped_column(nullable=True, index=True)
+    image_url: Mapped[Optional[str]] = mapped_column(nullable=True)
+    is_email_verified: Mapped[bool] = mapped_column(default=False)
+    is_mobile_verified: Mapped[bool] = mapped_column(default=False)
+    is_root_user: Mapped[bool] = mapped_column(default=True)
+    is_super_admin: Mapped[bool] = mapped_column(default=False)
+    disabled: Mapped[bool] = mapped_column(default=False)
+    disabled_reason: Mapped[Optional[str]] = mapped_column(nullable=True)
+    is_onboarded: Mapped[bool] = mapped_column(default=False)
+
+    @declared_attr
+    def login_histories(cls) -> Mapped["LoginHistory"]:
+        return relationship("LoginHistory", back_populates="account")
+
+    @declared_attr
+    def user(cls) -> Mapped["User"]:
+        return relationship("User", back_populates="account")
+
+
+class UserAccountSync(CustomSyncBase, UserAccountMixin):
+    pass
+
+
+class UserAccount(CustomBase, UserAccountMixin):
+    pass
+
+
+class LoginHistoryMixin:
+    """
+    This table is used to store the login history of users.
+    """
+    id: Mapped[int] = mapped_column(
+        primary_key=True, autoincrement=True, nullable=False
+    )
+    account_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("user_account.id"), nullable=False, index=True
+    )
+    ip_address: Mapped[str] = mapped_column(nullable=True)
+    created_at = mapped_column(DateTime, default=datetime.utcnow)
+
+    @declared_attr
+    def account(cls) -> Mapped["UserAccount"]:
+        return relationship("UserAccount", back_populates="login_histories")
+
+
+class LoginHistorySync(CustomSyncBase, LoginHistoryMixin):
+    pass
+
+
+class LoginHistory(CustomBase, LoginHistoryMixin):
+    pass
+
+
+class OAuthCsrfStateMixin(TimeStampMixin):
+    id: Mapped[str] = mapped_column(primary_key=True, unique=True)
+    client_base_url: Mapped[str] = mapped_column(nullable=True)
+
+
+class OAuthCsrfStateSync(CustomSyncBase, OAuthCsrfStateMixin):
+    pass
+
+
+class OAuthCsrfState(CustomBase, OAuthCsrfStateMixin):
+    pass

artemis_model/base.py

@@ -0,0 +1,222 @@
+import re
+from datetime import datetime
+from typing import Any
+
+from sqlalchemy.orm import (DeclarativeBase, Mapped, declared_attr,
+                            mapped_column, object_session, relationship)
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from sqlalchemy import Column, Uuid, event, inspect, TypeDecorator
+from sqlalchemy.dialects.postgresql import TSVECTOR
+
+
+def resolve_table_name(name: str) -> str:
+    """Resolves table names to their mapped names."""
+    names = re.split("(?=[A-Z])", name)  # noqa
+    print(names)
+    return "_".join([x.lower() for x in names if x])
+
+
+class CustomBase(DeclarativeBase, AsyncAttrs):
+    __repr_attrs__: list[Any] = []
+    __repr_max_length__ = 15
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return resolve_table_name(self.__name__)
+
+    def dict(self) -> dict:
+        """Returns a dict representation of a model."""
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}
+
+    @property
+    def _id_str(self) -> str:
+        ids = inspect(self).identity
+        if ids:
+            return "-".join([str(x) for x in ids]) if len(ids) > 1 else str(ids[0])
+        else:
+            return "None"
+
+    @property
+    def _repr_attrs_str(self) -> str:
+        max_length = self.__repr_max_length__
+
+        values = []
+        single = len(self.__repr_attrs__) == 1
+        for key in self.__repr_attrs__:
+            if not hasattr(self, key):
+                raise KeyError(
+                    "{} has incorrect attribute '{}' in "
+                    "__repr__attrs__".format(self.__class__, key)
+                )
+            value = getattr(self, key)
+            wrap_in_quote = isinstance(value, str)
+
+            value = str(value)
+            if len(value) > max_length:
+                value = value[:max_length] + "..."
+
+            if wrap_in_quote:
+                value = "'{}'".format(value)
+            values.append(value if single else "{}:{}".format(key, value))
+
+        return " ".join(values)
+
+    def __repr__(self) -> str:
+        # get id like '#123'
+        id_str = ("#" + self._id_str) if self._id_str else ""
+        # join class name, id and repr_attrs
+        return "<{} {}{}>".format(
+            self.__class__.__name__,
+            id_str,
+            " " + self._repr_attrs_str if self._repr_attrs_str else "",
+        )
+
+
+class AuditMixin(object):
+    created_by = Column(Uuid, nullable=True)
+    updated_by = Column(Uuid, nullable=True)
+
+    @declared_attr
+    def created_by_user(cls):
+        return relationship(
+            "User",
+            foreign_keys=[cls.created_by],
+            primaryjoin="User.id==%s.created_by" % cls.__name__,
+        )
+
+    @declared_attr
+    def updated_by_user(cls):
+        return relationship(
+            "User",
+            foreign_keys=[cls.updated_by],
+            primaryjoin="User.id==%s.updated_by" % cls.__name__,
+        )
+
+    @staticmethod
+    def _updated_info(mapper: Any, connection: Any, target: Any) -> None:
+        s = object_session(target)
+        target.updated_at = datetime.utcnow()
+        if user_id := getattr(s, "user_id", None):
+            target.updated_by = user_id
+
+    @staticmethod
+    def _created_info(mapper: Any, connection: Any, target: Any) -> None:
+        s = object_session(target)
+        if user_id := getattr(s, "user_id", None):
+            target.created_by = user_id
+
+    @classmethod
+    def get_session_user_id(cls, connection):
+        return connection.info.get("user_id")
+
+    @classmethod
+    def __declare_last__(cls) -> None:
+        event.listen(cls, "before_insert", cls._created_info)
+        event.listen(cls, "before_update", cls._updated_info)
+
+
+class TimeStampMixin(object):
+    """Timestamping mixin"""
+
+    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
+    created_at._creation_order = 9998
+    updated_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
+    updated_at._creation_order = 9998
+
+    @staticmethod
+    def _updated_at(mapper, connection, target):
+        target.updated_at = datetime.utcnow()
+
+    @classmethod
+    def __declare_last__(cls):
+        event.listen(cls, "before_update", cls._updated_at)
+
+
+# class InheritanceMixin(object):
+#     @declared_attr
+#     def __mapper_args__(cls):
+#         return {
+#             'polymorphic_identity': cls.__name__.lower(),
+#         }
+
+
+# class CustomBase(Base, AsyncAttrs):
+#     pass
+
+
+# class SyncInheritanceMixin(object):
+#     type = Column(String(50))
+
+#     @declared_attr
+#     def __mapper_args__(cls):
+#         return {
+#             'polymorphic_identity': cls.__name__.lower(),
+#             'polymorphic_on': 'type',
+#         }
+
+
+class CustomSyncBase(DeclarativeBase):
+    __repr_attrs__: list[Any] = []
+    __repr_max_length__ = 15
+    __abstract__ = True
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return resolve_table_name(self.__name__)
+
+    """ Is this missed here or not moved intentionally?"""
+
+    # def serializable_dict(self) -> Dict[str, Any]:
+    #     d = {col.name: getattr(self, col.name) for col in self.__table__.columns}
+    #     return orjson.loads(orjson.dumps(jsonable_encoder(d)))
+
+    def dict(self) -> dict:
+        """Returns a dict representation of a model."""
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}
+
+    @property
+    def _id_str(self) -> str:
+        ids = inspect(self).identity
+        if ids:
+            return "-".join([str(x) for x in ids]) if len(ids) > 1 else str(ids[0])
+        else:
+            return "None"
+
+    @property
+    def _repr_attrs_str(self) -> str:
+        max_length = self.__repr_max_length__
+
+        values = []
+        single = len(self.__repr_attrs__) == 1
+        for key in self.__repr_attrs__:
+            if not hasattr(self, key):
+                raise KeyError(
+                    "{} has incorrect attribute '{}' in "
+                    "__repr__attrs__".format(self.__class__, key)
+                )
+            value = getattr(self, key)
+            wrap_in_quote = isinstance(value, str)
+
+            value = str(value)
+            if len(value) > max_length:
+                value = value[:max_length] + "..."
+
+            if wrap_in_quote:
+                value = "'{}'".format(value)
+            values.append(value if single else "{}:{}".format(key, value))
+
+        return " ".join(values)
+
+    def __repr__(self) -> str:
+        # get id like '#123'
+        id_str = ("#" + self._id_str) if self._id_str else ""
+        # join class name, id and repr_attrs
+        return "<{} {}{}>".format(
+            self.__class__.__name__,
+            id_str,
+            " " + self._repr_attrs_str if self._repr_attrs_str else "",
+        )
+
+
+class TSVector(TypeDecorator):
+    impl = TSVECTOR

artemis_model/category.py

@@ -0,0 +1,60 @@
+from sqlalchemy import ARRAY, Computed, String, func, literal, text
+from sqlalchemy.ext.associationproxy import AssociationProxy, association_proxy
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import CustomSyncBase, TimeStampMixin, TSVector, CustomBase
+
+from sqlalchemy.ext.declarative import declared_attr
+
+from artemis_model.playlist import PlaylistCategoryAssoc
+
+
+def to_tsvector_ix(*columns):
+    s = " || ' ' || ".join(columns)
+    return func.to_tsvector(literal("english"), text(s))
+
+
+class CategoryMixin(TimeStampMixin):
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    sub_categories: Mapped[list[str]] = mapped_column(ARRAY(String), default=[])
+
+    name_tsv = mapped_column(
+        TSVector(),
+        Computed("to_tsvector('english', name)", persisted=True),
+    )
+
+    @declared_attr
+    def category_playlist_associations(cls) -> Mapped[list["PlaylistCategoryAssoc"]]:
+        return relationship(back_populates="category", cascade="all, delete-orphan")
+
+    @declared_attr
+    def playlists(cls) -> AssociationProxy[list["Playlist"]]:
+        return association_proxy(
+            "playlist_category_assoc",
+            "playlist",
+            creator=lambda p: PlaylistCategoryAssoc(playlist_id=p),
+        )
+
+    # __table_args__ = (
+    #     Index(
+    #         "fts_ix_category_name_tsv",
+    #         to_tsvector_ix("name"),
+    #         postgresql_using="gin",
+    #     ),
+    # )
+
+    @property
+    def is_subcategory(self) -> bool:
+        if self.sub_categories:
+            return True
+
+        return False
+
+
+class CategorySync(CustomSyncBase, CategoryMixin):
+    pass
+
+
+class Category(CustomBase, CategoryMixin):
+    pass

artemis_model/dj_set.py

@@ -0,0 +1,120 @@
+import uuid
+from datetime import datetime
+
+from sqlalchemy import Computed, ForeignKey, ARRAY, Integer
+from sqlalchemy.ext.associationproxy import AssociationProxy, association_proxy
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import CustomBase, CustomSyncBase, TSVector, TimeStampMixin, AuditMixin
+from sqlalchemy.ext.declarative import declared_attr
+
+
+class DjSetGenreAssocMixin(TimeStampMixin):
+    dj_set_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("dj_set.id"), primary_key=True, nullable=False
+    )
+    genre_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("genre.id"), primary_key=True, nullable=False
+    )
+    weight: Mapped[int] = mapped_column(nullable=False, default=0)
+
+    @declared_attr
+    def genre(cls) -> Mapped["Genre"]:
+        return relationship(back_populates="dj_set_genre_associations")
+
+
+class DjSetGenreAssocSync(CustomSyncBase, DjSetGenreAssocMixin):
+    pass
+
+
+class DjSetGenreAssoc(CustomBase, DjSetGenreAssocMixin):
+    pass
+
+
+class DjSetMixin(TimeStampMixin, AuditMixin):
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(nullable=False, unique=True)
+    organization_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("organization.id"), nullable=True, index=True
+    )
+    entry_date: Mapped[datetime] = mapped_column(
+        nullable=False, default=datetime.utcnow
+    )
+    cover_image: Mapped[str] = mapped_column(nullable=True)
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+    legacy_id: Mapped[str] = mapped_column(nullable=True)
+    description: Mapped[str | None] = mapped_column(nullable=True)
+    mood: Mapped[list[int]] = mapped_column(ARRAY(Integer), nullable=False, default=[0, 0])
+    decades: Mapped[list[int] | None] = mapped_column(ARRAY(Integer), nullable=True)
+    total_duration: Mapped[int] = mapped_column(nullable=False, default=0)
+
+    name_tsv = mapped_column(
+        TSVector(),
+        Computed("to_tsvector('english', name)", persisted=True),
+    )
+
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        return relationship(back_populates="dj_sets")
+
+    @declared_attr
+    def genre_ids(cls) -> AssociationProxy[list["Genre"] | None]:
+        return association_proxy(
+            "dj_set_genre_associations",
+            "genre",
+            creator=lambda genre: DjSetGenreAssoc(genre_id=genre.get("id"), weight=genre.get("weight", 0)),
+        )
+
+    @declared_attr
+    def dj_set_genre_associations(cls) -> Mapped[list["DjSetGenreAssoc"]]:
+        return relationship(cascade="all, delete-orphan")
+
+    @declared_attr
+    def dj_set_track_associations(cls) -> Mapped[list["DjSetTrackAssoc"]]:
+        return relationship(
+            cascade="all, delete-orphan"
+        )
+
+    @declared_attr
+    def genres(cls) -> Mapped[list["Genre"]]:
+        return relationship(
+            secondary="dj_set_genre_assoc",
+            lazy="joined",
+            viewonly=True
+        )
+
+
+@declared_attr
+def tracks(cls) -> Mapped[list["Track"]]:
+    return relationship(
+        secondary="dj_set_track_assoc", viewonly=True
+    )
+
+
+class DjSetSync(CustomSyncBase, DjSetMixin):
+    pass
+
+
+class DjSet(CustomBase, DjSetMixin):
+    pass
+
+
+class DjSetTrackAssocMixin(TimeStampMixin):
+    dj_set_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("dj_set.id"), primary_key=True, nullable=False
+    )
+    track_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("track.id"), primary_key=True, nullable=False
+    )
+
+    @declared_attr
+    def track(cls) -> Mapped["Track"]:
+        return relationship(back_populates="dj_set_track_associations")
+
+
+class DjSetTrackAssocSync(CustomSyncBase, DjSetTrackAssocMixin):
+    pass
+
+
+class DjSetTrackAssoc(CustomBase, DjSetTrackAssocMixin):
+    pass