0.2.64 update
This commit is contained in:
ponzischeme89
@@ -0,0 +1,293 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
// The database half of credits marking.
|
||||
//
|
||||
// Four queries, and the shape of each one is chosen to keep the promise the subsystem makes
|
||||
// about database activity: a settled household reads one indexed row per candidate and
|
||||
// writes nothing at all. Nothing here is written per candidate, per queue transition or per
|
||||
// scan attempt — only a finished marker.
|
||||
|
||||
// CreditsMarkerRow is one stored marker.
|
||||
type CreditsMarkerRow struct {
|
||||
ItemID string
|
||||
MediaFingerprint string
|
||||
CreditsStartMs int64
|
||||
Confidence float64
|
||||
DetectionMethod string
|
||||
SeriesID string
|
||||
Season int
|
||||
CreatedAt time.Time
|
||||
UpdatedAt time.Time
|
||||
}
|
||||
|
||||
// CreditsMarker reads the marker for one media version. Absence is an ordinary answer.
|
||||
func (s *Store) CreditsMarker(
|
||||
ctx context.Context, itemID, fingerprint string,
|
||||
) (CreditsMarkerRow, bool, error) {
|
||||
var row CreditsMarkerRow
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT item_id, media_fingerprint, credits_start_ms, confidence, detection_method,
|
||||
series_id, season_number, created_at, updated_at
|
||||
FROM credits_markers
|
||||
WHERE item_id = $1 AND media_fingerprint = $2`, itemID, fingerprint).
|
||||
Scan(&row.ItemID, &row.MediaFingerprint, &row.CreditsStartMs, &row.Confidence,
|
||||
&row.DetectionMethod, &row.SeriesID, &row.Season, &row.CreatedAt, &row.UpdatedAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return CreditsMarkerRow{}, false, nil
|
||||
}
|
||||
if err != nil {
|
||||
return CreditsMarkerRow{}, false, fmt.Errorf("store: credits marker: %w", err)
|
||||
}
|
||||
return row, true, nil
|
||||
}
|
||||
|
||||
// SaveCreditsMarker upserts one marker. This is the single write the whole subsystem makes,
|
||||
// and the caller has already decided that the new evidence is worth it — the stability rule
|
||||
// lives in the credits package beside the confidence model it depends on, not here.
|
||||
//
|
||||
// created_at is preserved on conflict so a marker's age remains the age of the finding rather
|
||||
// than of the last time something confirmed it.
|
||||
func (s *Store) SaveCreditsMarker(ctx context.Context, row CreditsMarkerRow) error {
|
||||
_, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO credits_markers (
|
||||
item_id, media_fingerprint, credits_start_ms, confidence, detection_method,
|
||||
series_id, season_number, created_at, updated_at
|
||||
) VALUES ($1, $2, $3, $4, $5, $6, $7, now(), now())
|
||||
ON CONFLICT (item_id, media_fingerprint) DO UPDATE SET
|
||||
credits_start_ms = EXCLUDED.credits_start_ms,
|
||||
confidence = EXCLUDED.confidence,
|
||||
detection_method = EXCLUDED.detection_method,
|
||||
series_id = EXCLUDED.series_id,
|
||||
season_number = EXCLUDED.season_number,
|
||||
updated_at = now()`,
|
||||
row.ItemID, row.MediaFingerprint, row.CreditsStartMs, row.Confidence,
|
||||
row.DetectionMethod, row.SeriesID, row.Season)
|
||||
if err != nil {
|
||||
return fmt.Errorf("store: save credits marker: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CreditsSeasonMarkers reads what is already known about a season, best evidence first.
|
||||
//
|
||||
// This is the single most valuable query in the subsystem. Credits within a season begin at
|
||||
// a consistent point, so two decided episodes turn the next one's ten-minute tail scan into a
|
||||
// three-minute one — which is most of the difference between a feature that is affordable on
|
||||
// a NAS and one that is not.
|
||||
func (s *Store) CreditsSeasonMarkers(
|
||||
ctx context.Context, seriesID string, season, limit int,
|
||||
) ([]CreditsMarkerRow, error) {
|
||||
if seriesID == "" || limit <= 0 {
|
||||
return nil, nil
|
||||
}
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT item_id, media_fingerprint, credits_start_ms, confidence, detection_method,
|
||||
series_id, season_number, created_at, updated_at
|
||||
FROM credits_markers
|
||||
WHERE series_id = $1 AND season_number = $2
|
||||
ORDER BY confidence DESC, updated_at DESC
|
||||
LIMIT $3`, seriesID, season, limit)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("store: credits season markers: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
out := make([]CreditsMarkerRow, 0, limit)
|
||||
for rows.Next() {
|
||||
var row CreditsMarkerRow
|
||||
if err := rows.Scan(&row.ItemID, &row.MediaFingerprint, &row.CreditsStartMs,
|
||||
&row.Confidence, &row.DetectionMethod, &row.SeriesID, &row.Season,
|
||||
&row.CreatedAt, &row.UpdatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// CreditsWatchRow is one episode one viewer played, as candidate generation needs it.
|
||||
type CreditsWatchRow struct {
|
||||
UserKey string
|
||||
SeriesID string
|
||||
Season int
|
||||
Episode int
|
||||
WatchedAt time.Time
|
||||
Completed bool
|
||||
}
|
||||
|
||||
// CreditsRecentWatches is the demand signal, and the whole of it: one indexed read of
|
||||
// sessions Tracearr has already imported.
|
||||
//
|
||||
// Nothing is written here and no new ingestion exists — the For You import already maintains
|
||||
// this table and already resolves its rows to Emby ids. That reuse is why demand-driven
|
||||
// candidate generation costs the gateway a single query every ten minutes rather than a
|
||||
// second Tracearr integration.
|
||||
//
|
||||
// Episodes only, and only where the series resolved to something in Emby: a session that
|
||||
// could not be matched cannot produce a scannable candidate, and filtering in SQL keeps the
|
||||
// unmatched majority of an old library out of Go entirely.
|
||||
func (s *Store) CreditsRecentWatches(
|
||||
ctx context.Context, since time.Time, limit int,
|
||||
) ([]CreditsWatchRow, error) {
|
||||
if limit <= 0 {
|
||||
limit = 500
|
||||
}
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT
|
||||
coalesce(nullif(tracearr_user_id, ''), lower(username)) AS user_key,
|
||||
emby_series_id,
|
||||
coalesce(season_number, 0),
|
||||
coalesce(episode_number, 0),
|
||||
coalesce(stopped_at, started_at) AS watched_at,
|
||||
watched OR (total_duration_ms > 0
|
||||
AND progress_ms::float8 / total_duration_ms::float8 >= 0.9) AS completed
|
||||
FROM tracearr_sessions
|
||||
WHERE lower(media_type) = 'episode'
|
||||
AND emby_series_id <> ''
|
||||
AND episode_number IS NOT NULL AND episode_number > 0
|
||||
AND coalesce(stopped_at, started_at) >= $1
|
||||
AND coalesce(nullif(tracearr_user_id, ''), lower(username)) <> ''
|
||||
ORDER BY coalesce(stopped_at, started_at) DESC
|
||||
LIMIT $2`, since.UTC(), limit)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("store: credits recent watches: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
out := make([]CreditsWatchRow, 0, 64)
|
||||
for rows.Next() {
|
||||
var row CreditsWatchRow
|
||||
if err := rows.Scan(&row.UserKey, &row.SeriesID, &row.Season,
|
||||
&row.Episode, &row.WatchedAt, &row.Completed); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// CreditsStopRow is one viewer leaving one episode.
|
||||
type CreditsStopRow struct {
|
||||
UserKey string
|
||||
PositionMs int64
|
||||
RuntimeMs int64
|
||||
NextEpisode bool
|
||||
}
|
||||
|
||||
// CreditsStops reads where the household stopped one episode.
|
||||
//
|
||||
// The behavioural detector's entire input, and it needs no new table: Tracearr already
|
||||
// records progress and completion per session. NextEpisode is derived rather than stored —
|
||||
// a session for the following episode of the same series starting within a couple of minutes
|
||||
// of this one ending is an auto-advance, which is the strongest form of this signal because
|
||||
// it says the viewer was unambiguously looking at credits rather than deciding to stop.
|
||||
func (s *Store) CreditsStops(ctx context.Context, itemID string) ([]CreditsStopRow, error) {
|
||||
if itemID == "" {
|
||||
return nil, nil
|
||||
}
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
WITH plays AS (
|
||||
SELECT
|
||||
coalesce(nullif(tracearr_user_id, ''), lower(username)) AS user_key,
|
||||
emby_series_id,
|
||||
season_number,
|
||||
episode_number,
|
||||
progress_ms,
|
||||
total_duration_ms,
|
||||
coalesce(stopped_at, started_at) AS ended_at
|
||||
FROM tracearr_sessions
|
||||
WHERE emby_item_id = $1
|
||||
AND progress_ms > 0
|
||||
AND total_duration_ms > 0
|
||||
AND coalesce(nullif(tracearr_user_id, ''), lower(username)) <> ''
|
||||
)
|
||||
SELECT
|
||||
plays.user_key,
|
||||
plays.progress_ms,
|
||||
plays.total_duration_ms,
|
||||
EXISTS (
|
||||
SELECT 1 FROM tracearr_sessions following
|
||||
WHERE following.emby_series_id = plays.emby_series_id
|
||||
AND coalesce(nullif(following.tracearr_user_id, ''), lower(following.username))
|
||||
= plays.user_key
|
||||
AND following.season_number = plays.season_number
|
||||
AND following.episode_number = plays.episode_number + 1
|
||||
AND following.started_at BETWEEN plays.ended_at - interval '30 seconds'
|
||||
AND plays.ended_at + interval '3 minutes'
|
||||
) AS next_episode
|
||||
FROM plays
|
||||
LIMIT 200`, itemID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("store: credits stops: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
out := make([]CreditsStopRow, 0, 16)
|
||||
for rows.Next() {
|
||||
var row CreditsStopRow
|
||||
if err := rows.Scan(&row.UserKey, &row.PositionMs, &row.RuntimeMs,
|
||||
&row.NextEpisode); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// CreditsEpisodeRow is one episode's position in its series.
|
||||
type CreditsEpisodeRow struct {
|
||||
ItemID string
|
||||
SeriesID string
|
||||
Season int
|
||||
Episode int
|
||||
}
|
||||
|
||||
// CreditsSeriesEpisodes reads the numbering of every episode of the given series.
|
||||
//
|
||||
// One query for the handful of series a household is currently watching, rather than a
|
||||
// lookup per candidate. The result becomes an in-memory index, so the look-ahead arithmetic
|
||||
// — including stepping across a season boundary, which is exactly when somebody is most
|
||||
// likely to keep going — is pure and testable with no database at all.
|
||||
func (s *Store) CreditsSeriesEpisodes(
|
||||
ctx context.Context, seriesIDs []string,
|
||||
) ([]CreditsEpisodeRow, error) {
|
||||
if len(seriesIDs) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT
|
||||
id,
|
||||
series_id,
|
||||
coalesce((payload->>'ParentIndexNumber')::int, 0),
|
||||
coalesce((payload->>'IndexNumber')::int, 0)
|
||||
FROM library_items
|
||||
WHERE type = 'Episode'
|
||||
AND series_id = ANY($1)
|
||||
AND payload->>'IndexNumber' IS NOT NULL`, seriesIDs)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("store: credits series episodes: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
out := make([]CreditsEpisodeRow, 0, 128)
|
||||
for rows.Next() {
|
||||
var row CreditsEpisodeRow
|
||||
if err := rows.Scan(&row.ItemID, &row.SeriesID, &row.Season, &row.Episode); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if row.Episode <= 0 {
|
||||
continue
|
||||
}
|
||||
out = append(out, row)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
Reference in New Issue
Block a user