Senko-san
58b98ab5ed
Adds nullable storage fields + availability column on tracks, remote source/source_id identity on albums/artists, TrackRepository.materialize() and get_or_create_remote() repos — groundwork for on-demand YTM library (placeholders saved without audio, materialized in-place on first play). Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
111 lines
3.9 KiB
Python
111 lines
3.9 KiB
Python
"""Artist repository — adapter over ``AsyncSession``."""
|
|
|
|
import uuid
|
|
|
|
from sqlalchemy import func, select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.domain.entities.track import Artist
|
|
from app.infrastructure.db.models.album import AlbumModel
|
|
from app.infrastructure.db.models.artist import ArtistModel
|
|
from app.infrastructure.db.models.track import TrackModel
|
|
|
|
|
|
def _to_entity(row: ArtistModel) -> Artist:
|
|
return Artist(
|
|
id=row.id,
|
|
name=row.name,
|
|
source=row.source,
|
|
source_id=row.source_id,
|
|
created_at=row.created_at,
|
|
updated_at=row.updated_at,
|
|
)
|
|
|
|
|
|
class SqlAlchemyArtistRepository:
|
|
def __init__(self, session: AsyncSession) -> None:
|
|
self._session = session
|
|
|
|
async def get_or_create(self, name: str) -> Artist:
|
|
row = (
|
|
await self._session.execute(select(ArtistModel).where(ArtistModel.name == name))
|
|
).scalar_one_or_none()
|
|
if row is None:
|
|
row = ArtistModel(name=name)
|
|
self._session.add(row)
|
|
await self._session.flush()
|
|
await self._session.refresh(row)
|
|
return _to_entity(row)
|
|
|
|
async def get_or_create_remote(self, *, name: str, source: str, source_id: str) -> Artist:
|
|
"""Resolve an artist by ``(source, source_id)`` first (re-browse/save
|
|
dedup), falling back to ``name`` and gap-filling the remote ids onto an
|
|
existing row, else creating a new remote-bound row."""
|
|
row = (
|
|
await self._session.execute(
|
|
select(ArtistModel).where(
|
|
ArtistModel.source == source,
|
|
ArtistModel.source_id == source_id,
|
|
)
|
|
)
|
|
).scalar_one_or_none()
|
|
if row is None:
|
|
row = (
|
|
await self._session.execute(select(ArtistModel).where(ArtistModel.name == name))
|
|
).scalar_one_or_none()
|
|
if row is None:
|
|
row = ArtistModel(name=name, source=source, source_id=source_id)
|
|
self._session.add(row)
|
|
elif row.source is None and row.source_id is None:
|
|
row.source = source
|
|
row.source_id = source_id
|
|
await self._session.flush()
|
|
await self._session.refresh(row)
|
|
return _to_entity(row)
|
|
|
|
async def get_by_id(self, artist_id: uuid.UUID) -> Artist | None:
|
|
row = await self._session.get(ArtistModel, artist_id)
|
|
return _to_entity(row) if row is not None else None
|
|
|
|
async def get_many(self, ids: list[uuid.UUID]) -> list[Artist]:
|
|
if not ids:
|
|
return []
|
|
rows = (
|
|
(await self._session.execute(select(ArtistModel).where(ArtistModel.id.in_(ids))))
|
|
.scalars()
|
|
.all()
|
|
)
|
|
return [_to_entity(r) for r in rows]
|
|
|
|
async def list(self, *, q: str | None, limit: int, offset: int) -> list[Artist]:
|
|
stmt = select(ArtistModel)
|
|
if q:
|
|
stmt = stmt.where(ArtistModel.name.ilike(f"%{q}%"))
|
|
stmt = stmt.order_by(ArtistModel.name).limit(limit).offset(offset)
|
|
rows = (await self._session.execute(stmt)).scalars().all()
|
|
return [_to_entity(r) for r in rows]
|
|
|
|
async def count(self, *, q: str | None) -> int:
|
|
stmt = select(func.count()).select_from(ArtistModel)
|
|
if q:
|
|
stmt = stmt.where(ArtistModel.name.ilike(f"%{q}%"))
|
|
return (await self._session.execute(stmt)).scalar_one()
|
|
|
|
async def album_count(self, artist_id: uuid.UUID) -> int:
|
|
return (
|
|
await self._session.execute(
|
|
select(func.count())
|
|
.select_from(AlbumModel)
|
|
.where(AlbumModel.artist_id == artist_id)
|
|
)
|
|
).scalar_one()
|
|
|
|
async def track_count(self, artist_id: uuid.UUID) -> int:
|
|
return (
|
|
await self._session.execute(
|
|
select(func.count())
|
|
.select_from(TrackModel)
|
|
.where(TrackModel.artist_id == artist_id)
|
|
)
|
|
).scalar_one()
|