photoanalyzer/photo_pipeline/services/library.py

"""LibraryService — read-only Library and Stats over analysis results.

Ports webapp/query.py (search, facets, stats, top-tag/people/year aggregates) onto
the shared database, re-keyed to ``asset_id`` and joined to ``assets`` for the
current path. The donor read a path-keyed ``photos`` table with an FTS5 index; here
search is a tokenised ``LIKE`` over description + tags.
ponytail: restore FTS5 (rank-ordered relevance) if search recall/latency matters at
real library size — LIKE is fine for browsing tens of thousands of rows.

Extracted from webapp/query.py (donor_ledger.yaml: wa-query-search, wa-query-stats).
Read-only: writes belong to AnalysisService.
"""

from __future__ import annotations

import json
import re
from collections import Counter
from pathlib import Path

from sqlalchemy import and_, func, or_, select
from sqlalchemy.orm import sessionmaker

from photo_pipeline.models import AnalysisResult, Asset

CARD_FIELDS = (
    "status",
    "description",
    "people_count",
    "setting",
    "time_of_day",
    "season",
    "mood",
    "location_hint",
    "approx_year",
)
DONE = ("analyzed",)
_SORTS = {
    "year": (AnalysisResult.approx_year.desc(), Asset.current_path),
    "people": (AnalysisResult.people_count.desc(), Asset.current_path),
    "recent": (AnalysisResult.analyzed_at.desc(), Asset.current_path),
    "path": (Asset.current_path,),
}


def _album_of(path: str | None) -> str:
    return Path(path).parent.name if path else "(unknown)"


class LibraryService:
    def __init__(self, session_factory: sessionmaker) -> None:
        self._session_factory = session_factory

    def search(self, q="", filters=None, sort="path", offset=0, limit=60) -> dict:
        filters = filters or {}
        with self._session_factory() as session:
            stmt = select(AnalysisResult, Asset.current_path).join(
                Asset, Asset.id == AnalysisResult.asset_id
            )
            conds = _filter_conditions(filters)
            for token in re.findall(r"\w+", q, re.UNICODE):
                like = f"%{token}%"
                conds.append(
                    or_(AnalysisResult.description.ilike(like), AnalysisResult.tags.ilike(like))
                )
            if conds:
                stmt = stmt.where(and_(*conds))
            total = session.scalar(select(func.count()).select_from(stmt.subquery()))
            stmt = stmt.order_by(*_SORTS.get(sort, _SORTS["path"])).limit(limit).offset(offset)
            rows = [_card(result, path) for result, path in session.execute(stmt)]
        return {"rows": rows, "total": total, "offset": offset, "limit": limit}

    def stats(self) -> dict:
        with self._session_factory() as session:
            status = dict(
                session.execute(
                    select(AnalysisResult.status, func.count()).group_by(AnalysisResult.status)
                ).all()
            )
            rows = list(
                session.execute(
                    select(AnalysisResult, Asset.current_path).join(
                        Asset, Asset.id == AnalysisResult.asset_id
                    )
                )
            )
            albums: dict[str, dict] = {}
            tag_counts: Counter = Counter()
            year_counts: Counter = Counter()
            people: Counter = Counter()
            errors = []
            for result, path in rows:
                album = _album_of(path)
                bucket = albums.setdefault(album, {"album": album, "done": 0, "total": 0})
                bucket["total"] += 1
                if result.status in DONE:
                    bucket["done"] += 1
                for tag in _tags(result.tags):
                    tag_counts[tag] += 1
                if result.approx_year is not None:
                    year_counts[result.approx_year] += 1
                if result.people_count is not None:
                    people["3+" if result.people_count >= 3 else str(result.people_count)] += 1
                if result.status == "error":
                    errors.append({"path": path, "error": result.error_message})
        return {
            "total": sum(status.values()),
            "status": status,
            "setting": self._facet("setting"),
            "time_of_day": self._facet("time_of_day"),
            "season": self._facet("season"),
            "people": [{"value": v, "count": n} for v, n in sorted(people.items())],
            "years": [{"value": y, "count": year_counts[y]} for y in sorted(year_counts)],
            "top_tags": [{"value": t, "count": n} for t, n in tag_counts.most_common(40)],
            "albums": sorted(albums.values(), key=lambda d: d["album"]),
            "errors": sorted(errors, key=lambda e: e["path"] or ""),
        }

    def facets(self) -> dict:
        return {
            "setting": self._facet("setting"),
            "time_of_day": self._facet("time_of_day"),
            "season": self._facet("season"),
            "status": self._facet("status"),
        }

    def _facet(self, field: str) -> list[dict]:
        column = getattr(AnalysisResult, field)
        with self._session_factory() as session:
            rows = session.execute(
                select(column, func.count())
                .where(column.is_not(None), func.trim(column) != "")
                .group_by(column)
                .order_by(func.count().desc())
            ).all()
        return [{"value": value, "count": count} for value, count in rows]


def _filter_conditions(filters: dict) -> list:
    conds = []
    for key, column in (
        ("setting", AnalysisResult.setting),
        ("tod", AnalysisResult.time_of_day),
        ("season", AnalysisResult.season),
        ("status", AnalysisResult.status),
    ):
        if filters.get(key):
            conds.append(column == filters[key])
    people = filters.get("people")
    if people == "3+":
        conds.append(AnalysisResult.people_count >= 3)
    elif people in ("0", "1", "2"):
        conds.append(AnalysisResult.people_count == int(people))
    if filters.get("year_min"):
        conds.append(AnalysisResult.approx_year >= int(filters["year_min"]))
    if filters.get("year_max"):
        conds.append(AnalysisResult.approx_year <= int(filters["year_max"]))
    if filters.get("has_location"):
        conds.append(
            and_(
                AnalysisResult.location_hint.is_not(None),
                func.trim(AnalysisResult.location_hint) != "",
                func.lower(AnalysisResult.location_hint) != "null",
            )
        )
    return conds


def _card(result: AnalysisResult, path: str | None) -> dict:
    card = {field: getattr(result, field) for field in CARD_FIELDS}
    card.update(
        asset_id=result.asset_id,
        current_path=path,
        album=_album_of(path),
        tags=_tags(result.tags),
    )
    return card


def _tags(raw: str | None) -> list[str]:
    if not raw:
        return []
    try:
        return json.loads(raw)
    except (ValueError, TypeError):
        return []