audio streaming app
plyr.fm
fix(copyright): suppress self-match flags before they reach UI/DM (#1341)
flo.by uploaded his catalog; AuDD identified each track's dominant
match as "Floby IV" (his stage name). every scan returned
is_flagged=true, which:
- showed a red "potential copyright violation" badge to the
artist on his own /portal page
- fired an admin DM ("copyright flag on plyr.fm / primary: X
by Floby IV") — admin received ~30 DMs in one session
`sync_copyright_resolutions` flipped is_flagged=false within 5min,
but only after the artist had already seen the flag and the DM
spam had landed.
fix: in `_store_scan_result`, look up the uploader's artist record
when is_flagged=true and compare slugified forms of the dominant
match artist to the uploader's handle and display name. on a
self-match, demote is_flagged to false at write time so the UI
flag and the DM never fire. logs `copyright self-match suppressed`
for observability.
separate semantic bug (sync flipping flags whose URI was never
labelled, not just negated) is unaddressed here — this is the
short-term fix to stop creator-visible flags + DM spam.
Co-authored-by: Claude Opus 4 (1M context) <noreply@anthropic.com>
authored by
nate nowack
Claude Opus 4 (1M context)
and committed by
GitHub
c213426b
f7946389
+323
-13
+91
-13
backend/src/backend/_internal/moderation.py
+91
-13
backend/src/backend/_internal/moderation.py
···
1
1
"""moderation service integration for copyright scanning."""
2
2
3
3
import logging
4
+
from collections import Counter
4
5
from typing import Any
5
6
6
7
import logfire
···
15
16
16
17
logger = logging.getLogger(__name__)
17
18
19
+
_SELF_MATCH_MIN_SLUG_LEN = 4
20
+
21
+
22
+
def _slugify_artist(name: str) -> str:
23
+
"""lowercase, alphanumeric-only — for fuzzy artist-name comparison."""
24
+
return "".join(c for c in name.lower() if c.isalnum())
25
+
26
+
27
+
def _is_self_match(
28
+
match_artist: str, uploader_handle: str, uploader_display: str
29
+
) -> bool:
30
+
"""detect when a copyright match's artist is the uploader themselves.
31
+
32
+
AuDD frequently identifies an artist's own catalog uploads as
33
+
"violations" of their own published works elsewhere (e.g. dominant
34
+
match "Floby IV" on a track uploaded by handle "flo.by"). this is
35
+
a false positive — flagging it spams admin DMs and shows a red
36
+
badge to the artist on their own portal.
37
+
38
+
we compare slugified forms (lowercase, alphanumeric only) of the
39
+
match artist against the uploader's handle and display name. a
40
+
bidirectional substring check catches stage-name variants in
41
+
either direction (e.g. "flo.by" → "floby" is contained in
42
+
"Floby IV" → "flobyiv"). minimum length avoids accidental
43
+
matches on very short slugs.
44
+
"""
45
+
m = _slugify_artist(match_artist)
46
+
if len(m) < _SELF_MATCH_MIN_SLUG_LEN:
47
+
return False
48
+
for candidate in (uploader_handle, uploader_display):
49
+
if not candidate:
50
+
continue
51
+
c = _slugify_artist(candidate)
52
+
if len(c) >= _SELF_MATCH_MIN_SLUG_LEN and (c in m or m in c):
53
+
return True
54
+
return False
55
+
56
+
57
+
def _dominant_match_artist(matches: list[dict[str, Any]]) -> str | None:
58
+
"""return the most frequent artist in scan matches, or None if empty."""
59
+
counts = Counter(
60
+
(m.get("artist") or "").strip() for m in matches if m.get("artist")
61
+
)
62
+
if not counts:
63
+
return None
64
+
artist, _ = counts.most_common(1)[0]
65
+
return artist or None
66
+
18
67
19
68
async def scan_track_for_copyright(track_id: int, audio_url: str) -> None:
20
69
"""scan a track for potential copyright matches.
···
63
112
result: ScanResult from moderation client
64
113
"""
65
114
async with db_session() as db:
115
+
# decide effective is_flagged BEFORE the row is written so the
116
+
# transient flag never reaches the UI / DM path. self-matches
117
+
# (uploader is the dominant match artist) get demoted to clear.
118
+
is_flagged = result.is_flagged
119
+
suppressed_self_match: str | None = None
120
+
121
+
if is_flagged:
122
+
track = await db.scalar(
123
+
select(Track)
124
+
.options(joinedload(Track.artist))
125
+
.where(Track.id == track_id)
126
+
)
127
+
dominant = _dominant_match_artist(result.matches)
128
+
if (
129
+
track
130
+
and track.artist
131
+
and dominant
132
+
and _is_self_match(
133
+
dominant, track.artist.handle, track.artist.display_name or ""
134
+
)
135
+
):
136
+
is_flagged = False
137
+
suppressed_self_match = dominant
138
+
else:
139
+
track = None
140
+
66
141
scan = CopyrightScan(
67
142
track_id=track_id,
68
-
is_flagged=result.is_flagged,
143
+
is_flagged=is_flagged,
69
144
highest_score=result.highest_score,
70
145
matches=result.matches,
71
146
raw_response=result.raw_response,
···
73
148
db.add(scan)
74
149
await db.commit()
75
150
151
+
if suppressed_self_match:
152
+
logfire.info(
153
+
"copyright self-match suppressed",
154
+
track_id=track_id,
155
+
dominant_artist=suppressed_self_match,
156
+
uploader_handle=track.artist.handle if track and track.artist else None,
157
+
)
158
+
return
159
+
76
160
logfire.info(
77
161
"copyright scan stored",
78
162
track_id=track_id,
···
82
166
)
83
167
84
168
# notify admin only — never DM the artist
85
-
if result.is_flagged:
86
-
track = await db.scalar(
87
-
select(Track)
88
-
.options(joinedload(Track.artist))
89
-
.where(Track.id == track_id)
169
+
if is_flagged and track and track.artist:
170
+
await notification_service.send_copyright_flag_notification(
171
+
track_id=track_id,
172
+
track_title=track.title,
173
+
artist_handle=track.artist.handle,
174
+
matches=scan.matches,
90
175
)
91
-
if track and track.artist:
92
-
await notification_service.send_copyright_flag_notification(
93
-
track_id=track_id,
94
-
track_title=track.title,
95
-
artist_handle=track.artist.handle,
96
-
matches=scan.matches,
97
-
)
98
176
99
177
100
178
async def _store_scan_error(track_id: int, error: str) -> None:
+232
backend/tests/_internal/test_copyright_self_match.py
+232
backend/tests/_internal/test_copyright_self_match.py
···
1
+
"""regression: self-match copyright flags must not surface to UI or DMs.
2
+
3
+
history: 2026-04-25 — flo.by uploaded a batch of his own catalog. AuDD
4
+
identified each track's dominant match as "Floby IV" (his stage name),
5
+
so every scan came back is_flagged=true. that path:
6
+
- wrote `copyright_scans.is_flagged=true` (visible to creator on /portal)
7
+
- fired admin DM "copyright flag on plyr.fm / primary: X by Floby IV"
8
+
9
+
the artist saw red badges on his own tracks and reached out; the admin
10
+
got 30 DM spams in an hour. the perpetual sync flipped is_flagged=false
11
+
within 5min, but only after the damage was done.
12
+
13
+
fix: detect self-match by comparing slugified dominant artist vs uploader
14
+
handle/display_name. demote is_flagged to false at write time so the UI
15
+
flag and the DM never fire.
16
+
"""
17
+
18
+
from dataclasses import dataclass
19
+
from typing import Any
20
+
from unittest.mock import AsyncMock, patch
21
+
22
+
from sqlalchemy import select
23
+
from sqlalchemy.ext.asyncio import AsyncSession
24
+
25
+
from backend._internal.moderation import (
26
+
_dominant_match_artist,
27
+
_is_self_match,
28
+
_store_scan_result,
29
+
)
30
+
from backend.models import Artist, CopyrightScan, Track
31
+
32
+
33
+
@dataclass
34
+
class _FakeScanResult:
35
+
is_flagged: bool
36
+
highest_score: int
37
+
matches: list[dict[str, Any]]
38
+
raw_response: dict[str, Any]
39
+
40
+
41
+
def _matches(*pairs: tuple[str, str]) -> list[dict[str, Any]]:
42
+
return [{"artist": a, "title": t, "score": 0} for a, t in pairs]
43
+
44
+
45
+
# --- unit: _is_self_match ---
46
+
47
+
48
+
class TestIsSelfMatch:
49
+
def test_floby_iv_matches_flo_by_handle(self) -> None:
50
+
# the actual case that triggered this fix
51
+
assert _is_self_match("Floby IV", "flo.by", "flo.by") is True
52
+
53
+
def test_exact_handle_match(self) -> None:
54
+
assert _is_self_match("knock2one", "knock2one.bsky.social", "knock2one") is True
55
+
56
+
def test_display_name_substring(self) -> None:
57
+
assert _is_self_match("Mister X", "msx.bsky.social", "Mister") is True
58
+
59
+
def test_unrelated_artist_is_not_self_match(self) -> None:
60
+
# j4ck.xyz uploaded a Conan Gray cover — should NOT be suppressed
61
+
assert _is_self_match("Conan Gray", "j4ck.xyz", "j4ck.xyz") is False
62
+
63
+
def test_unrelated_artist_zedd(self) -> None:
64
+
# natalie.sh's "mid 123" matched "Zedd" — should NOT be suppressed
65
+
assert _is_self_match("Zedd", "natalie.sh", "natalie.sh") is False
66
+
67
+
def test_short_match_artist_not_suppressed(self) -> None:
68
+
# 3-char artist would otherwise over-match; require min slug length
69
+
assert _is_self_match("DJ", "djsomething.bsky.social", "DJ Some") is False
70
+
71
+
def test_empty_uploader_display_safe(self) -> None:
72
+
assert _is_self_match("Floby IV", "flo.by", "") is True
73
+
74
+
def test_empty_match_returns_false(self) -> None:
75
+
assert _is_self_match("", "flo.by", "flo.by") is False
76
+
77
+
78
+
# --- unit: _dominant_match_artist ---
79
+
80
+
81
+
class TestDominantMatchArtist:
82
+
def test_picks_most_frequent(self) -> None:
83
+
ms = _matches(
84
+
("Floby IV", "Summer Heat"),
85
+
("Floby IV", "Summer Heat"),
86
+
("Other", "song"),
87
+
)
88
+
assert _dominant_match_artist(ms) == "Floby IV"
89
+
90
+
def test_empty_returns_none(self) -> None:
91
+
assert _dominant_match_artist([]) is None
92
+
93
+
def test_skips_blank_artists(self) -> None:
94
+
ms = [{"artist": "", "title": "x"}, {"artist": "Real", "title": "y"}]
95
+
assert _dominant_match_artist(ms) == "Real"
96
+
97
+
98
+
# --- integration: _store_scan_result demotes self-matches ---
99
+
100
+
101
+
async def _make_artist_and_track(
102
+
db: AsyncSession,
103
+
*,
104
+
handle: str = "flo.by",
105
+
display_name: str = "flo.by",
106
+
did: str = "did:plc:test-flo",
107
+
title: str = "Summer Heat",
108
+
) -> Track:
109
+
artist = Artist(did=did, handle=handle, display_name=display_name)
110
+
db.add(artist)
111
+
await db.commit()
112
+
track = Track(
113
+
title=title,
114
+
file_id="abc123",
115
+
file_type="mp3",
116
+
artist_did=did,
117
+
r2_url="https://audio.plyr.fm/audio/abc123.mp3",
118
+
)
119
+
db.add(track)
120
+
await db.commit()
121
+
await db.refresh(track)
122
+
return track
123
+
124
+
125
+
async def test_store_scan_result_suppresses_self_match(
126
+
db_session: AsyncSession,
127
+
) -> None:
128
+
track = await _make_artist_and_track(db_session)
129
+
scan_result = _FakeScanResult(
130
+
is_flagged=True,
131
+
highest_score=0,
132
+
matches=_matches(
133
+
("Floby IV", "Summer Heat"),
134
+
("Floby IV", "Summer Heat"),
135
+
("Floby IV", "Summer Heat"),
136
+
),
137
+
raw_response={},
138
+
)
139
+
140
+
with patch(
141
+
"backend._internal.moderation.notification_service.send_copyright_flag_notification",
142
+
new_callable=AsyncMock,
143
+
) as mock_dm:
144
+
await _store_scan_result(track.id, scan_result)
145
+
146
+
# row was written with is_flagged=false (no UI flag)
147
+
rows = (
148
+
(
149
+
await db_session.execute(
150
+
select(CopyrightScan).where(CopyrightScan.track_id == track.id)
151
+
)
152
+
)
153
+
.scalars()
154
+
.all()
155
+
)
156
+
assert len(rows) == 1
157
+
assert rows[0].is_flagged is False
158
+
# admin DM NEVER fires for self-matches
159
+
mock_dm.assert_not_called()
160
+
161
+
162
+
async def test_store_scan_result_real_violation_still_flags(
163
+
db_session: AsyncSession,
164
+
) -> None:
165
+
track = await _make_artist_and_track(
166
+
db_session,
167
+
handle="j4ck.xyz",
168
+
display_name="j4ck.xyz",
169
+
did="did:plc:test-j4ck",
170
+
title="acoustic guitar cover of vodka cranberry",
171
+
)
172
+
scan_result = _FakeScanResult(
173
+
is_flagged=True,
174
+
highest_score=0,
175
+
matches=_matches(
176
+
("Conan Gray", "Vodka Cranberry"),
177
+
("Conan Gray", "Vodka Cranberry"),
178
+
("Conan Gray", "Vodka Cranberry"),
179
+
),
180
+
raw_response={},
181
+
)
182
+
183
+
with patch(
184
+
"backend._internal.moderation.notification_service.send_copyright_flag_notification",
185
+
new_callable=AsyncMock,
186
+
) as mock_dm:
187
+
await _store_scan_result(track.id, scan_result)
188
+
189
+
rows = (
190
+
(
191
+
await db_session.execute(
192
+
select(CopyrightScan).where(CopyrightScan.track_id == track.id)
193
+
)
194
+
)
195
+
.scalars()
196
+
.all()
197
+
)
198
+
assert len(rows) == 1
199
+
# genuine non-self-match: flag stays true and admin gets DM
200
+
assert rows[0].is_flagged is True
201
+
mock_dm.assert_awaited_once()
202
+
203
+
204
+
async def test_store_scan_result_clear_path_unchanged(
205
+
db_session: AsyncSession,
206
+
) -> None:
207
+
track = await _make_artist_and_track(db_session, did="did:plc:test-clear")
208
+
scan_result = _FakeScanResult(
209
+
is_flagged=False,
210
+
highest_score=0,
211
+
matches=[],
212
+
raw_response={},
213
+
)
214
+
215
+
with patch(
216
+
"backend._internal.moderation.notification_service.send_copyright_flag_notification",
217
+
new_callable=AsyncMock,
218
+
) as mock_dm:
219
+
await _store_scan_result(track.id, scan_result)
220
+
221
+
rows = (
222
+
(
223
+
await db_session.execute(
224
+
select(CopyrightScan).where(CopyrightScan.track_id == track.id)
225
+
)
226
+
)
227
+
.scalars()
228
+
.all()
229
+
)
230
+
assert len(rows) == 1
231
+
assert rows[0].is_flagged is False
232
+
mock_dm.assert_not_called()