artemis-model 0.1.112__tar.gz → 0.1.182__tar.gz

{artemis_model-0.1.112 → artemis_model-0.1.182}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: artemis-model
-Version: 0.1.112
+Version: 0.1.182
 Summary: 
 Author: Jukeboxy
 Requires-Python: >=3.10.6,<4.0.0
@@ -8,6 +8,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: alembic (>=1.13.1,<2.0.0)
 Requires-Dist: asyncpg (>=0.30.0,<0.31.0)
 Requires-Dist: greenlet (>=3.0.2,<4.0.0)

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/__init__.py

@@ -1,12 +1,15 @@
 from artemis_model.album import *  # noqa
+from artemis_model.approved_playlist_list 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.location_genre_exclusion import *  # noqa
 from artemis_model.message import *  # noqa
 from artemis_model.organization import *  # noqa
+from artemis_model.organization_include_pal_setting import *  # noqa
 from artemis_model.playlist import *  # noqa
 from artemis_model.schedule import *  # noqa
 from artemis_model.setting import *  # noqa
@@ -15,3 +18,5 @@ from artemis_model.user import *  # noqa
 from artemis_model.zone import *  # noqa
 from artemis_model.otp import *  # noqa
 from artemis_model.banned_tracks import *  # noqa
+from artemis_model.zone_activity import *  # noqa
+from artemis_model.zone_state import *  # noqa

artemis_model-0.1.182/artemis_model/approved_playlist_list.py

@@ -0,0 +1,55 @@
+import uuid
+from typing import List
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.ext.declarative import declared_attr
+
+from artemis_model.base import CustomSyncBase, TimeStampMixin, AuditMixin, CustomBase
+
+
+class ApprovedPlaylistListMixin(TimeStampMixin, AuditMixin):
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True, index=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    organization_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("organization.id"), nullable=False, index=True
+    )
+
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        return relationship("Organization", back_populates="approved_playlist_lists")
+
+    @declared_attr
+    def playlist_associations(cls) -> Mapped[List["ApprovedPlaylistListPlaylistAssoc"]]:
+        return relationship(cascade="all, delete-orphan")
+
+    @declared_attr
+    def playlists(cls) -> Mapped[List["Playlist"]]:
+        return relationship(
+            "Playlist", secondary="approved_playlist_list_playlist_assoc", viewonly=True
+        )
+
+
+class ApprovedPlaylistListSync(CustomSyncBase, ApprovedPlaylistListMixin):
+    pass
+
+
+class ApprovedPlaylistList(CustomBase, ApprovedPlaylistListMixin):
+    pass
+
+
+class ApprovedPlaylistListPlaylistAssocMixin(TimeStampMixin):
+    approved_playlist_list_id: Mapped[int] = mapped_column(
+        ForeignKey("approved_playlist_list.id"), primary_key=True, nullable=False
+    )
+    playlist_id: Mapped[int] = mapped_column(
+        ForeignKey("playlist.id"), primary_key=True, nullable=False
+    )
+
+
+class ApprovedPlaylistListPlaylistAssocSync(CustomSyncBase, ApprovedPlaylistListPlaylistAssocMixin):
+    pass
+
+
+class ApprovedPlaylistListPlaylistAssoc(CustomBase, ApprovedPlaylistListPlaylistAssocMixin):
+    pass

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/auth.py

@@ -1,14 +1,16 @@
 """Auth models."""
 
+from enum import Enum
 import uuid
 from datetime import datetime
 from typing import Optional
 
+from pydantic import BaseModel
 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
+from artemis_model.base import AuditMixin, CustomSyncBase, TimeStampMixin, CustomBase
 
 
 class UserUnverifiedAccountMixin(TimeStampMixin):
@@ -111,3 +113,79 @@ class OAuthCsrfStateSync(CustomSyncBase, OAuthCsrfStateMixin):
 
 class OAuthCsrfState(CustomBase, OAuthCsrfStateMixin):
     pass
+
+
+class OrionWebplayerCodeMixin(TimeStampMixin, AuditMixin):
+    """Orion webplayer code mixin."""
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    code_hash: Mapped[str] = mapped_column(
+        unique=True, nullable=False
+    )  # Argon2id of normalized code
+    name: Mapped[str] = mapped_column(nullable=False)
+    zone_id: Mapped[int] = mapped_column(nullable=False, index=True)
+
+
+class OrionWebplayerCodeSync(CustomSyncBase, OrionWebplayerCodeMixin):
+    pass
+
+
+class OrionWebplayerCode(CustomBase, OrionWebplayerCodeMixin):
+    pass
+
+
+class PlayerRefreshTokenMixin(TimeStampMixin):
+    """
+    Refresh token for Player.
+    We look up by token_id (PK), then verify `secret` against `secret_hash`.
+    """
+
+    # this is the public part we send to the client
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        primary_key=True,
+        default=uuid.uuid4,
+    )
+
+    code_id: Mapped[Optional[uuid.UUID]] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("orion_webplayer_code.id", ondelete="SET NULL"),
+        index=True,
+        nullable=True,
+    )
+
+    # store zone_id too (helps auth decisions / debugging)
+    zone_id: Mapped[Optional[int]] = mapped_column(index=True)
+
+    # bcrypt/argon2 hash of the secret part
+    secret_hash: Mapped[str] = mapped_column(nullable=False)
+    is_suspended: Mapped[bool] = mapped_column(default=False)
+
+
+class PlayerRefreshTokenSync(CustomSyncBase, PlayerRefreshTokenMixin):
+    pass
+
+
+class PlayerRefreshToken(CustomBase, PlayerRefreshTokenMixin):
+    pass
+
+
+class Scope(str, Enum):
+    """Scope enum."""
+
+    PLAYER = "player"
+    MANAGE = "manage"
+
+class TokenData(BaseModel):
+    """Token data."""
+
+    account_id: uuid.UUID
+    user_id: uuid.UUID
+    scope: Scope
+
+
+class RefreshTokenData(TokenData):
+    """Refresh token data."""
+
+    zone_id: int | None = None
+    code_id: uuid.UUID | None = None

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/banned_tracks.py

@@ -6,16 +6,19 @@ from artemis_model.base import AuditMixin, TimeStampMixin, CustomSyncBase, Custo
 
 
 class BannedTracksMixin(TimeStampMixin, AuditMixin):
-    """Banned Tracks per Zone Model"""    
+    """Banned Tracks per Zone Model"""
+
     zone_id: Mapped[int] = mapped_column(Integer, primary_key=True)
     track_id: Mapped[UUID] = mapped_column(UUID(as_uuid=True), primary_key=True)
 
 
 class BannedTracksSync(CustomSyncBase, BannedTracksMixin):
     """Banned Tracks per Zone Model"""
+
     pass
 
 
 class BannedTracks(CustomBase, BannedTracksMixin):
     """Banned Tracks per Zone Model"""
+
     pass

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/category.py

@@ -1,4 +1,4 @@
-from sqlalchemy import ARRAY, Computed, String, func, literal, text
+from sqlalchemy import Computed, func, literal, text
 from sqlalchemy.ext.associationproxy import AssociationProxy, association_proxy
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
@@ -16,12 +16,12 @@ def to_tsvector_ix(*columns):
 
 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=[])
+    main_category: Mapped[str] = mapped_column(nullable=False)
+    sub_category: Mapped[str] = mapped_column(nullable=False)
 
     name_tsv = mapped_column(
         TSVector(),
-        Computed("to_tsvector('english', name)", persisted=True),
+        Computed("to_tsvector('english', main_category || ' ' || sub_category)", persisted=True),
     )
 
     @declared_attr
@@ -39,18 +39,11 @@ class CategoryMixin(TimeStampMixin):
     # __table_args__ = (
     #     Index(
     #         "fts_ix_category_name_tsv",
-    #         to_tsvector_ix("name"),
+    #         to_tsvector_ix("main_category", "sub_category"),
     #         postgresql_using="gin",
     #     ),
     # )
 
-    @property
-    def is_subcategory(self) -> bool:
-        if self.sub_categories:
-            return True
-
-        return False
-
 
 class CategorySync(CustomSyncBase, CategoryMixin):
     pass

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/location.py

@@ -86,6 +86,14 @@ class LocationMixin(TimeStampMixin):
             cascade="all, delete-orphan",
         )
 
+    @declared_attr
+    def genre_exclusions(cls) -> Mapped[list["LocationGenreExclusion"]]:
+        return relationship(
+            "LocationGenreExclusion",
+            back_populates="location",
+            cascade="all, delete-orphan",
+        )
+
     timezone: Mapped[str] = mapped_column(nullable=False, default="America/New_York")
 
 

artemis_model-0.1.182/artemis_model/location_genre_exclusion.py

@@ -0,0 +1,38 @@
+import uuid
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.ext.declarative import declared_attr
+
+from artemis_model.base import TimeStampMixin, CustomSyncBase, CustomBase
+
+
+class LocationGenreExclusionMixin(TimeStampMixin):
+    """Association table for tracking which genres are excluded at the location level."""
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    location_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("location.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    genre_id: Mapped[int] = mapped_column(
+        ForeignKey("genre.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+
+    @declared_attr
+    def location(cls) -> Mapped["Location"]:
+        return relationship(back_populates="genre_exclusions")
+
+    @declared_attr
+    def genre(cls) -> Mapped["Genre"]:
+        return relationship()
+
+    __table_args__ = (
+        UniqueConstraint("location_id", "genre_id", name="unique_location_genre_exclusion"),
+    )
+
+
+class LocationGenreExclusionSync(CustomSyncBase, LocationGenreExclusionMixin):
+    pass
+
+
+class LocationGenreExclusion(CustomBase, LocationGenreExclusionMixin):
+    pass

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/organization.py

@@ -38,6 +38,27 @@ class OrganizationMixin(TimeStampMixin):
     def message_groups(cls) -> Mapped[List["MessageGroup"]]:
         return relationship(back_populates="organization")
 
+    @declared_attr
+    def include_pal_setting(cls) -> Mapped["OrganizationIncludePalSetting"]:
+        return relationship(
+            back_populates="organization", uselist=False, cascade="all, delete-orphan"
+        )
+
+    @declared_attr
+    def approved_playlist_lists(cls) -> Mapped[List["ApprovedPlaylistList"]]:
+        return relationship("ApprovedPlaylistList", back_populates="organization")
+
+    @property
+    def approved_playlists(self) -> List[int]:
+        """
+        Convenience property to get all playlist IDs from all approved lists, flattened.
+        Returns empty list if no approved lists exist.
+        """
+        playlist_ids = []
+        for approved_list in self.approved_playlist_lists:
+            playlist_ids.extend([playlist.id for playlist in approved_list.playlists])
+        return playlist_ids
+
 
 def generate_slug(target: Any, value: Any, old_value: Any, initiator: Any) -> None:
     """Creates a reasonable slug based on organization name."""

artemis_model-0.1.182/artemis_model/organization_include_pal_setting.py

@@ -0,0 +1,32 @@
+import uuid
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.ext.declarative import declared_attr
+
+from artemis_model.base import TimeStampMixin, CustomSyncBase, CustomBase
+
+
+class OrganizationIncludePalSettingMixin(TimeStampMixin):
+    """Organization-level setting for including parental advisory (explicit) content."""
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    organization_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("organization.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    include_pal: Mapped[bool] = mapped_column(nullable=False, default=False)
+
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        return relationship(back_populates="include_pal_setting")
+
+    __table_args__ = (
+        UniqueConstraint("organization_id", name="unique_organization_include_pal_setting"),
+    )
+
+
+class OrganizationIncludePalSettingSync(CustomSyncBase, OrganizationIncludePalSettingMixin):
+    pass
+
+
+class OrganizationIncludePalSetting(CustomBase, OrganizationIncludePalSettingMixin):
+    pass

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/playlist.py

@@ -1,7 +1,7 @@
 import uuid
 from datetime import date, datetime
 
-from sqlalchemy import Computed, ForeignKey, func, literal, text
+from sqlalchemy import Computed, ForeignKey, func, literal, text, ARRAY, String
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.ext.associationproxy import AssociationProxy, association_proxy
 from sqlalchemy.orm import Mapped, mapped_column, relationship
@@ -43,6 +43,8 @@ class PlaylistMixin(TimeStampMixin):
     published_at: Mapped[date | None] = mapped_column(nullable=True)
     is_private: Mapped[bool] = mapped_column(default=False)
     total_duration: Mapped[int] = mapped_column(default=0)
+    track_count: Mapped[int] = mapped_column(default=0)
+    artist_names: Mapped[list[str]] = mapped_column(ARRAY(String), nullable=False, default=[])
 
     name_tsv = mapped_column(
         TSVector(),

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/redis/__init__.py

@@ -1,6 +1,14 @@
 """Redis models."""
 
-from .zone_state import ZoneState, NowPlaying, SessionId, BucketId
+from .zone_state import (
+    ZoneState,
+    NowPlaying,
+    SessionId,
+    BucketTS,
+    PlaylistSimple,
+    PushedPlaylistDetails,
+    ScheduleDetails,
+)
 from .device import ActiveDevice
 from .bucket import RedisTrackBucketItem
 from .play_history import RedisTrackPlayHistoryItem
@@ -17,8 +25,11 @@ __all__ = [
     "ZoneState",
     "NowPlaying",
     "SessionId",
-    "BucketId",
+    "BucketTS",
     "ActiveDevice",
+    "PlaylistSimple",
+    "PushedPlaylistDetails",
+    "ScheduleDetails",
     "KEY_ZONE_PLAY_HISTORY_TEMPLATE",
     "KEY_ZONE_PUSH_PLAYLIST_BUCKET_TEMPLATE",
     "KEY_ZONE_SCHEDULE_BUCKET_TEMPLATE",

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/redis/bucket.py

@@ -1,25 +1,16 @@
 """Redis track buckets"""
-import json
+
 from pydantic import BaseModel, Field, ConfigDict
 from typing import Annotated
 from datetime import datetime, timezone
 import uuid
 
 
-TrackId = Annotated[
-    uuid.UUID,
-    Field(description="Track ID (UUID)")
-]
+TrackId = Annotated[uuid.UUID, Field(description="Track ID (UUID)")]
 
-PlaylistId = Annotated[
-    int,
-    Field(description="Playlist ID (integer)")
-]
+PlaylistId = Annotated[int, Field(description="Playlist ID (integer)")]
 
-Timestamp = Annotated[
-    int,
-    Field(description="Unix timestamp")
-]
+Timestamp = Annotated[int, Field(description="Unix timestamp")]
 
 
 class RedisTrackBucketItem(BaseModel):
@@ -34,10 +25,7 @@ class RedisTrackBucketItem(BaseModel):
     playlist_id: PlaylistId
     ts: Timestamp = Field(default_factory=lambda: int(datetime.now(timezone.utc).timestamp()))
 
-    model_config = ConfigDict(
-        json_encoders={uuid.UUID: str},
-        populate_by_name=True
-    )
+    model_config = ConfigDict(json_encoders={uuid.UUID: str}, populate_by_name=True)
 
     def as_redis_entry(self) -> dict[str, int]:
         """
@@ -46,8 +34,7 @@ class RedisTrackBucketItem(BaseModel):
         """
         key = self.model_dump_json(include={"track_id", "playlist_id"})
         return {key: self.ts}
-    
-    
+
     @classmethod
     def from_redis_entry(cls, entry: dict[str, int]) -> "RedisTrackBucketItem":
         """
@@ -58,5 +45,6 @@ class RedisTrackBucketItem(BaseModel):
 
 class RedisTrackBucketItemValue(BaseModel):
     """JSON string format for Redis keys: '{"track_id": "...", "playlist_id": ...}'"""
+
     track_id: TrackId
     playlist_id: PlaylistId

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/redis/device.py

@@ -13,7 +13,7 @@ class ActiveDevice(BaseModel):
     user_id: UUID
     client_id: str
     device_id: str
-    mode: Literal["player-mode", "controller-mode"]
+    mode: Literal["player-mode", "controller-mode", "force-player-mode"]
     connected_at: datetime | str = Field(
         default_factory=lambda: datetime.now(timezone.utc).isoformat()
     )

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/redis/keys.py

@@ -1,16 +1,18 @@
 """Redis keys."""
 
+KEY_ZONE_ACTIVE_DEVICE_TEMPLATE = "zone_{zone_id}_active_devices"
 KEY_ZONE_PLAY_HISTORY_TEMPLATE = "zone_{zone_id}_play_history"
 KEY_ZONE_PUSH_PLAYLIST_BUCKET_TEMPLATE = "zone_{zone_id}_pp_bucket_{timeslot_ts}"
 KEY_ZONE_SCHEDULE_BUCKET_TEMPLATE = "zone_{zone_id}_sc_bucket_{timeslot_ts}"
+KEY_ZONE_SKIPPED_TRACKS_TEMPLATE = "zone_{zone_id}_skipped_tracks"
 KEY_ZONE_STATE_TEMPLATE = "zone_{zone_id}_state"
-KEY_ZONE_ACTIVE_DEVICE_TEMPLATE = "zone_{zone_id}_active_devices"
 
 
 __all__ = [
+    "KEY_ZONE_ACTIVE_DEVICE_TEMPLATE",
     "KEY_ZONE_PLAY_HISTORY_TEMPLATE",
     "KEY_ZONE_PUSH_PLAYLIST_BUCKET_TEMPLATE",
     "KEY_ZONE_SCHEDULE_BUCKET_TEMPLATE",
+    "KEY_ZONE_SKIPPED_TRACKS_TEMPLATE",
     "KEY_ZONE_STATE_TEMPLATE",
-    "KEY_ZONE_ACTIVE_DEVICE_TEMPLATE",
 ]

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/redis/play_history.py

@@ -5,15 +5,9 @@ from typing import Annotated
 from datetime import datetime, timezone
 
 
-TrackId = Annotated[
-    str,
-    Field(description="Track ID (UUID or string)")
-]
+TrackId = Annotated[str, Field(description="Track ID (UUID or string)")]
 
-Timestamp = Annotated[
-    int,
-    Field(description="Unix timestamp")
-]
+Timestamp = Annotated[int, Field(description="Unix timestamp")]
 
 
 class RedisTrackPlayHistoryItem(BaseModel):
@@ -21,6 +15,7 @@ class RedisTrackPlayHistoryItem(BaseModel):
     Represents the value stored in Redis sorted set:
     A string like "track_id#timestamp"
     """
+
     track_id: TrackId
     ts: Timestamp = Field(default_factory=lambda: int(datetime.now(timezone.utc).timestamp()))
 

artemis_model-0.1.182/artemis_model/redis/zone_state.py

@@ -0,0 +1,111 @@
+"""Zone state schema."""
+
+from datetime import datetime
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, Field
+
+
+class NowPlaying(BaseModel):
+    """Now playing schema."""
+
+    name: str = Field(description="The name of the track", default="UNKNOWN")
+    artist_name: str = Field(description="The artist name of the track", default="UNKNOWN")
+    album_name: str = Field(description="The album name of the track", default="UNKNOWN")
+    playlist_id: int | None = Field(description="The playlist id of the track", default=None)
+
+
+SessionId = Annotated[
+    int,
+    Field(
+        description="The session id of the pushed playlist. It's generated as a timestamp value of the current time."
+    ),
+]
+BucketTS = Annotated[
+    int | None,
+    Field(
+        description="The bucket id of the pushed playlist. It's calculated as the timestamp value of the timeslot."
+    ),
+]
+
+
+class PlaylistSimple(BaseModel):
+    """Simple playlist schema."""
+
+    id: int = Field(
+        description="The id of the pushed playlist. It's generated as a timestamp value of the current time."
+    )
+    name: str = Field(
+        description="The name of the pushed playlist",
+    )
+
+
+class ScheduleDetails(BaseModel):
+    """Schedule details schema."""
+
+    start_at: datetime | None = Field(
+        default=None,
+        description="The date and time value of the schedule in local timezone.",
+    )
+    playlists: list[PlaylistSimple] | None = Field(
+        default=None,
+        description="The playlist of the schedule",
+    )
+
+
+class PushedPlaylistDetails(BaseModel):
+    """Player details schema."""
+
+    bucket_key: str | None = Field(
+        description="""Pushed playlists does exist in Redis with a timestamp.
+        Example: zone_{zone_id}_pp_bucket_{ts}
+        """,
+    )
+    playlists: list[PlaylistSimple] | None = Field(
+        default=None,
+        description="The playlists of the pushed playlist",
+    )
+    expire_at: datetime | None = Field(
+        default=None,
+        description="The expire time of the pushed playlist",
+    )
+    expiry_type: Literal["infinite", "auto_expire"] | None = Field(
+        default=None,
+        description="The expiry type of the pushed playlist",
+    )
+
+
+class ZoneState(BaseModel):
+    """Zone state schema."""
+
+    player_mode: Literal["scheduled", "pushplaylist"] = Field(
+        default="scheduled",
+        description="The mode of the player",
+    )
+    player_state: Literal["playing", "paused", "stopped", "ready"] = Field(
+        default="ready",
+        description="The state of the player",
+    )
+    now_playing: NowPlaying | None = Field(
+        default=None,
+        description="The currently playing track",
+    )
+    pp_details: PushedPlaylistDetails | None = Field(
+        default=None,
+        description="The details of the pushed playlist",
+    )
+    schedule_details: ScheduleDetails | None = Field(
+        default=None,
+        description="The details of the schedule",
+    )
+
+
+__all__ = [
+    "ZoneState",
+    "NowPlaying",
+    "SessionId",
+    "BucketTS",
+    "PlaylistSimple",
+    "PushedPlaylistDetails",
+    "ScheduleDetails",
+]

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/setting.py

@@ -25,7 +25,7 @@ class SettingMixin(TimeStampMixin):
             "<track_id>": "<track_name>",
             ...
         },
-        "exclude_pal": True/False
+        "include_pal": True/False
     }
     """
 

{artemis_model-0.1.112 → artemis_model-0.1.182}/artemis_model/sqs/messages.py

@@ -6,10 +6,11 @@ from typing import Literal
 from uuid import UUID
 
 
-from artemis_model.redis.zone_state import SessionId
 from artemis_model.schedule import ScheduleItem
 from pydantic import BaseModel, Field
 
+from artemis_model.zone_activity import ZoneActivityType
+
 
 class Action(str, Enum):
     """Message type enum."""
@@ -24,6 +25,8 @@ class Action(str, Enum):
     RECALCULATE_SCHEDULE = "recalculate-schedule"
     PLAYER_MODE_CHANGE = "player-mode-change"
     BAN_TRACK = "ban-track"
+    ZONE_ACTIVITY = "zone-activity"
+    STOP_MUSIC = "stop-music"
 
 
 class BaseMessage(BaseModel):
@@ -41,7 +44,15 @@ class MoveTimeSlotIn(BaseMessage):
 
     action: Action = Action.MOVE_TIME_SLOT
     zone_id: int
-    timeslot: str
+    bucket_key: str
+    playlist_ids: list[int]
+
+
+class StopMusicIn(BaseMessage):
+    """Stop music message schema."""
+
+    action: Action = Action.STOP_MUSIC
+    zone_id: int
 
 
 class TriageScheduleIn(BaseMessage):
@@ -66,9 +77,6 @@ class PushPlaylistIn(BaseMessage):
     expire_at: datetime | None = Field(
         default=None, description="The datetime that the playlist will expire"
     )
-    session_id: SessionId = Field(
-        default_factory=lambda: int(datetime.now(timezone.utc).timestamp()),
-    )
 
 
 class PushPlaylistExpireIn(BaseMessage):
@@ -77,7 +85,7 @@ class PushPlaylistExpireIn(BaseMessage):
     action: Action = Action.EXPIRE_PUSHED_PLAYLIST
     zone_id: int
     new_mode: Literal["pushplaylist", "scheduled"] = "scheduled"
-    session_id: SessionId | None = None
+    bucket_key: str | None = None
 
 
 class RefreshTrackBucketIn(BaseMessage):
@@ -85,6 +93,7 @@ class RefreshTrackBucketIn(BaseMessage):
 
     action: Action = Action.REFRESH_TRACK_BUCKET
     zone_id: int
+    bucket_key: str
 
 
 class RecalculateScheduleIn(BaseMessage):
@@ -101,3 +110,13 @@ class BanTrackIn(BaseMessage):
     zone_id: int
     track_id: UUID
     playlist_id: int
+    bucket_key: str
+
+
+class ZoneActivityIn(BaseMessage):
+    """Zone activity message schema."""
+
+    action: Action = Action.ZONE_ACTIVITY
+    zone_id: int
+    activity_type: ZoneActivityType
+    activity_data: dict

artemis_model-0.1.182/artemis_model/zone_activity.py

@@ -0,0 +1,48 @@
+"""Zone Activity Model"""
+
+from enum import StrEnum
+from sqlalchemy import Integer, String, JSON, Index
+from sqlalchemy.orm import Mapped, mapped_column
+from artemis_model.base import AuditMixin, TimeStampMixin, CustomSyncBase, CustomBase
+
+
+class ZoneActivityType(StrEnum):
+    """Zone activity type"""
+
+    CONNECTED = "connected"
+    CONNECTION_MODE_CHANGED = "connection_mode_changed"
+    DISCONNECTED = "disconnected"
+    PLAYER_PAUSED = "player_paused"
+    PLAYER_RESUMED = "player_resumed"
+    TRACK_SKIPPED = "track_skipped"
+    TRACK_LIKED = "track_liked"
+    TRACK_BANNED = "track_banned"
+    TRACK_UNBANNED = "track_unbanned"
+    PLAYLIST_PUSHED = "playlist_pushed"
+    PLAYLIST_EXPIRED = "playlist_expired"
+    ACTIVE_PLAYLIST_CHANGED = "active_playlist_changed"
+
+
+class PlayerActivityMixin(TimeStampMixin, AuditMixin):
+    """User activity log, sorted by created_at DESC for retrieval"""
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    player_id: Mapped[int] = mapped_column(Integer, nullable=False)
+    activity_type: Mapped[str] = mapped_column(String, nullable=False)
+    activity_data: Mapped[dict] = mapped_column(JSON, nullable=True)
+
+
+Index("idx_player_activity_player_created", "player_id", PlayerActivityMixin.created_at.desc())
+Index("idx_player_activity_created", PlayerActivityMixin.created_at.desc())
+
+
+class PlayerActivitySync(CustomSyncBase, PlayerActivityMixin):
+    """Sync model for Player Activity"""
+
+    pass
+
+
+class PlayerActivity(CustomBase, PlayerActivityMixin):
+    """Base model for Player Activity"""
+
+    pass

artemis_model-0.1.182/artemis_model/zone_state.py

@@ -0,0 +1,88 @@
+"""Zone state data models."""
+
+# models/zone_state.py
+
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.ext.declarative import declared_attr
+
+from artemis_model.base import CustomSyncBase, TimeStampMixin, CustomBase
+
+
+class ZoneStateMetaMixin(TimeStampMixin):
+    """
+    Rarely changing part of a zone's state.
+    One row per zone.
+    """
+
+    zone_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("zone.id", ondelete="CASCADE"),
+        primary_key=True,
+        default=uuid.uuid4,
+        doc="Zone identifier (PK)",
+    )
+
+    player_mode: Mapped[str] = mapped_column(
+        String, default="scheduled", nullable=False, index=True
+    )
+    player_state: Mapped[str] = mapped_column(String, default="ready", nullable=False, index=True)
+    pp_details: Mapped[Optional[dict]] = mapped_column(JSONB, nullable=True)
+    schedule_details: Mapped[Optional[dict]] = mapped_column(JSONB, nullable=True)
+
+    @declared_attr
+    def now_playing(cls) -> Mapped["ZoneNowPlaying"]:
+        return relationship(
+            "ZoneNowPlaying",
+            back_populates="meta",
+            uselist=False,
+            cascade="all, delete-orphan",
+        )
+
+
+class ZoneStateMetaSync(CustomSyncBase, ZoneStateMetaMixin):
+    pass
+
+
+class ZoneStateMeta(CustomBase, ZoneStateMetaMixin):
+    pass
+
+
+class ZoneNowPlayingMixin:
+    """
+    Frequently changing part of a zone's state.
+    Keep row narrow; PK-only index for cheap updates.
+    One row per zone (FK to ZoneStateMeta).
+    """
+
+    zone_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("zone_state_meta.zone_id", ondelete="CASCADE"),
+        primary_key=True,
+        doc="Matches zone_state_meta.zone_id",
+    )
+
+    track_name: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    artist_name: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    album_name: Mapped[Optional[str]] = mapped_column(String, nullable=True)
+    playlist_id: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
+
+    # Lightweight timestamp for freshness; mirrors your style (see LoginHistory)
+    updated_at = mapped_column(DateTime, default=datetime.utcnow, nullable=False)
+
+    @declared_attr
+    def meta(cls) -> Mapped["ZoneStateMeta"]:
+        return relationship("ZoneStateMeta", back_populates="now_playing")
+
+
+class ZoneNowPlayingSync(CustomSyncBase, ZoneNowPlayingMixin):
+    pass
+
+
+class ZoneNowPlaying(CustomBase, ZoneNowPlayingMixin):
+    pass

{artemis_model-0.1.112 → artemis_model-0.1.182}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "artemis-model"
-version = "0.1.112"
+version = "0.1.182"
 description = ""
 authors = ["Jukeboxy"]
 readme = "README.md"

artemis_model-0.1.112/artemis_model/redis/zone_state.py

@@ -1,57 +0,0 @@
-"""Zone state schema."""
-
-from typing import Annotated, Literal
-
-from pydantic import BaseModel, Field, field_validator
-
-
-class NowPlaying(BaseModel):
-    """Now playing schema."""
-
-    name: str = Field(description="The name of the track", default="UNKNOWN")
-    artist_name: str = Field(description="The artist name of the track", default="UNKNOWN")
-    album_name: str = Field(description="The album name of the track", default="UNKNOWN")
-
-
-SessionId = Annotated[
-    int,
-    Field(
-        description="The session id of the pushed playlist. It's generated as a timestamp value of the current time."
-    ),
-]
-BucketId = Annotated[
-    int | None,
-    Field(
-        description="The bucket id of the pushed playlist. It's calculated in set_bucket_track as the timestamp value of the timeslot."
-    ),
-]
-
-
-class ZoneState(BaseModel):
-    """Zone state schema."""
-
-    player_mode: Literal["scheduled", "pushplaylist"] = Field(
-        default="scheduled",
-        description="The mode of the player",
-    )
-    player_state: Literal["playing", "paused", "stopped", "ready"] = Field(
-        default="ready",
-        description="The state of the player",
-    )
-    now_playing: NowPlaying | None = Field(
-        default=None,
-        description="The currently playing track",
-    )
-    push_playlist_details: dict[SessionId, BucketId] | None = Field(
-        default_factory=dict,
-        description="The details of the pushed playlist",
-    )
-
-    @field_validator("push_playlist_details", mode="before")
-    @classmethod
-    def default_empty_dict_if_none(cls, v):
-        """Override none value to empty dict."""
-        return v or {}
-
-
-__all__ = ["ZoneState", "NowPlaying", "SessionId", "BucketId"]