237 lines
11 KiB
TypeScript
237 lines
11 KiB
TypeScript
// 身份识别重评(ID-2):匹配规则更新后,处理存量的待识别事项与错误映射。默认只读(dry-run),加 --apply 才改库。
|
|
//
|
|
// 用法(DATABASE_URL 必须显式给出,脚本不带默认库):
|
|
// DATABASE_URL=postgres://umt:***@<host>:5432/umt deno run -A scripts/identity-reevaluate.ts
|
|
// DATABASE_URL=… deno run -A scripts/identity-reevaluate.ts --rollback-wrong # 另查分类词别名造成的错误映射
|
|
// DATABASE_URL=… deno run -A scripts/identity-reevaluate.ts --rollback-wrong --apply # 真正执行
|
|
//
|
|
// 1. open 的 identity_ambiguous:按新解析规则重新解析每个成员资源并给出预估(只用池里存的候选,不查 TMDB);
|
|
// --apply 时把这些池条目的 next_review_at 置为现在、attempts 清零,由运行中的服务(已部署新规则)的池复查
|
|
// 重新识别——能自动确认的会绑定作品、建映射,并从合并事项里摘除(组空即关闭)。脚本自己不查 TMDB、不建作品。
|
|
// 2. --rollback-wrong:找出站点来源(source=site)且是分类词 / 停用词 / 单字的别名(例如 RSS 前缀「[电视剧]」被当成
|
|
// 中文名登记的「电视剧」),对挂着这类别名的作品,用新解析 + 作品自身名称(主标题 / 原标题 / 非站点来源别名)
|
|
// 重新核对已绑定的资源:对不上的视为经错误别名误并入 → --apply 时解除绑定、退回待识别池(立即复查),
|
|
// 删除该错误别名以及由误并入资源登记的站点别名(链式扩散的那些),各记一条 resolution_attempt(manual)。
|
|
// 内容单元(季 / 集)不删,只列出已无资源引用的单元。
|
|
|
|
import {
|
|
type IdentityCandidate,
|
|
isGenericAliasName,
|
|
normalizeTitle,
|
|
parseRelease,
|
|
queryTitles,
|
|
resolveIdentity,
|
|
scoreCandidate,
|
|
} from "@umt/domain";
|
|
import pg from "pg";
|
|
|
|
const args = new Set(Deno.args);
|
|
const APPLY = args.has("--apply");
|
|
const ROLLBACK = args.has("--rollback-wrong");
|
|
const url = Deno.env.get("DATABASE_URL");
|
|
if (!url) {
|
|
console.error("需要 DATABASE_URL(脚本不带默认库)");
|
|
Deno.exit(2);
|
|
}
|
|
const db = new pg.Client({ connectionString: url });
|
|
await db.connect();
|
|
const q = async <T>(text: string, values: unknown[] = []) => (await db.query(text, values)).rows as T[];
|
|
const mode = APPLY ? "APPLY" : "DRY-RUN";
|
|
console.log(`# identity-reevaluate (${mode})${ROLLBACK ? " + rollback-wrong" : ""}\n`);
|
|
|
|
interface PoolRow {
|
|
pool_id: string;
|
|
decision_id: string;
|
|
decision_title: string;
|
|
source_release_id: string;
|
|
title: string;
|
|
subtitle: string | null;
|
|
candidates: {
|
|
provider: string;
|
|
entityType: "movie" | "tv";
|
|
externalId: string;
|
|
title: string;
|
|
year: number | null;
|
|
}[];
|
|
}
|
|
|
|
// ---------------------------------------------------------------- 1. open identity_ambiguous
|
|
const pool = await q<PoolRow>(
|
|
`select c.id as pool_id, d.id as decision_id, d.title as decision_title, r.id as source_release_id, r.title, r.subtitle,
|
|
c.candidates
|
|
from decision d
|
|
join identity_candidate c on c.decision_id = d.id and c.status = 'pending'
|
|
join source_release r on r.id = c.source_release_id
|
|
where d.kind = 'identity_ambiguous' and d.status in ('open', 'investigating', 'awaiting_user')
|
|
order by d.id, r.title`,
|
|
);
|
|
console.log(
|
|
`## open identity_ambiguous:${new Set(pool.map((p) => p.decision_id)).size} 条事项,${pool.length} 个成员资源`,
|
|
);
|
|
let predictedAuto = 0;
|
|
for (const p of pool) {
|
|
const parsed = parseRelease(p.title, p.subtitle ? { subtitle: p.subtitle } : {});
|
|
const cands: IdentityCandidate[] = (p.candidates ?? []).map((c) => ({
|
|
provider: c.provider,
|
|
entityType: c.entityType,
|
|
externalId: c.externalId,
|
|
titles: [c.title],
|
|
aliases: [],
|
|
...(c.year != null ? { year: c.year } : {}),
|
|
}));
|
|
const res = resolveIdentity(parsed, cands);
|
|
if (res.status === "auto") predictedAuto++;
|
|
const best = res.best?.candidate;
|
|
console.log(
|
|
`- [${res.status}${res.status === "auto" ? ` → ${best?.provider}:${best?.entityType}/${best?.externalId} ${best?.titles[0]}` : ""}] ` +
|
|
`${p.title} (中文名 ${parsed.titleCn ?? "-"},英文名 ${parsed.titleEn ?? "-"},年份 ${parsed.year ?? "-"})`,
|
|
);
|
|
}
|
|
console.log(
|
|
`\n预估(只用池里存的候选,服务复查时会按新规则重新查 TMDB 并比对别名,结果以复查为准):${predictedAuto}/${pool.length} 可自动确认`,
|
|
);
|
|
if (APPLY && pool.length) {
|
|
await q(`update identity_candidate set next_review_at = now(), attempts = 0 where id = any($1::uuid[])`, [
|
|
pool.map((p) => p.pool_id),
|
|
]);
|
|
console.log(`已把 ${pool.length} 个池条目排入立即复查(由运行中的服务处理)`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------- 2. rollback-wrong
|
|
if (ROLLBACK) {
|
|
interface AliasRow {
|
|
id: string;
|
|
media_entity_id: string;
|
|
alias: string;
|
|
normalized: string;
|
|
source: string;
|
|
}
|
|
const siteAliases = await q<AliasRow>(
|
|
`select id, media_entity_id, alias, normalized, source from title_alias where source = 'site' and content_unit_id is null`,
|
|
);
|
|
const poison = siteAliases.filter((a) => isGenericAliasName(a.normalized));
|
|
const entities = [...new Set(poison.map((a) => a.media_entity_id))];
|
|
console.log(`\n## rollback-wrong:${poison.length} 个分类词 / 通用词站点别名,涉及 ${entities.length} 部作品`);
|
|
const toUnbind: { id: string; title: string; subtitle: string | null; entityId: string }[] = [];
|
|
const aliasIdsToDelete = new Set(poison.map((a) => a.id));
|
|
for (const entityId of entities) {
|
|
const [e] = await q<{
|
|
id: string;
|
|
kind: string;
|
|
title: string;
|
|
original_title: string | null;
|
|
year: number | null;
|
|
}>(`select id, kind, title, original_title, year from media_entity where id = $1`, [entityId]);
|
|
if (!e) continue;
|
|
const all = await q<AliasRow>(
|
|
`select id, media_entity_id, alias, normalized, source from title_alias where media_entity_id = $1`,
|
|
[entityId],
|
|
);
|
|
// 作品自身名称:主标题 / 原标题 / 非站点来源的别名(TMDB 译名等)
|
|
const legit: IdentityCandidate = {
|
|
provider: "local",
|
|
entityType: e.kind === "movie" ? "movie" : "tv",
|
|
externalId: e.id,
|
|
titles: [e.title, ...(e.original_title ? [e.original_title] : [])],
|
|
aliases: all.filter((a) => a.source !== "site").map((a) => a.alias),
|
|
...(e.year != null ? { year: e.year } : {}),
|
|
};
|
|
const legitNorm = new Set([...legit.titles, ...legit.aliases].map(normalizeTitle));
|
|
const releases = await q<{ id: string; title: string; subtitle: string | null; parsed: Record<string, unknown> }>(
|
|
`select id, title, subtitle, parsed from source_release where media_entity_id = $1 and not resolution_locked`,
|
|
[entityId],
|
|
);
|
|
const wrongNames = new Set<string>();
|
|
let kept = 0;
|
|
for (const r of releases) {
|
|
const parsed = parseRelease(r.title, r.subtitle ? { subtitle: r.subtitle } : {});
|
|
const s = scoreCandidate(parsed, legit);
|
|
if (s.titleMatch === "exact" || s.titleMatch === "alias") {
|
|
kept++;
|
|
continue;
|
|
}
|
|
toUnbind.push({ id: r.id, title: r.title, subtitle: r.subtitle, entityId });
|
|
for (const n of queryTitles(parsed)) wrongNames.add(n);
|
|
for (const k of ["titleCn", "titleEn", "title"]) {
|
|
const v = r.parsed?.[k];
|
|
if (typeof v === "string" && v) wrongNames.add(normalizeTitle(v));
|
|
}
|
|
}
|
|
const chain = all.filter(
|
|
(a) => a.source === "site" && !legitNorm.has(a.normalized) && wrongNames.has(a.normalized),
|
|
);
|
|
for (const a of chain) aliasIdsToDelete.add(a.id);
|
|
console.log(
|
|
`\n### ${e.title}(${e.year ?? "-"}):已绑定 ${releases.length} 条,核对通过 ${kept} 条,误并入 ${releases.length - kept} 条`,
|
|
);
|
|
console.log(
|
|
` 删除别名:${[...new Set([...poison.filter((a) => a.media_entity_id === entityId), ...chain].map((a) => `「${a.alias}」`))].join(" ") || "-"}`,
|
|
);
|
|
for (const r of toUnbind.filter((x) => x.entityId === entityId)) console.log(` - 解除:${r.title}`);
|
|
}
|
|
// 引用了这些资源的其他记录(只报告,不改)
|
|
if (toUnbind.length) {
|
|
const refs = await q<{ table_name: string }>(
|
|
`select table_name from information_schema.columns
|
|
where table_schema = 'public' and column_name = 'source_release_id'
|
|
and table_name not in ('identity_candidate', 'resolution_attempt', 'observation')`,
|
|
);
|
|
for (const { table_name } of refs) {
|
|
const [c] = await q<{ n: number }>(
|
|
`select count(*)::int as n from "${table_name}" where source_release_id = any($1::uuid[])`,
|
|
[toUnbind.map((r) => r.id)],
|
|
);
|
|
if (c && c.n > 0) console.log(` 注意:${table_name} 里有 ${c.n} 行引用了误并入的资源(不自动处理,请人工核对)`);
|
|
}
|
|
}
|
|
console.log(`\n合计:解除 ${toUnbind.length} 条资源绑定,删除 ${aliasIdsToDelete.size} 个站点别名`);
|
|
if (APPLY && (toUnbind.length || aliasIdsToDelete.size)) {
|
|
await db.query("begin");
|
|
try {
|
|
await q(`delete from title_alias where id = any($1::uuid[])`, [[...aliasIdsToDelete]]);
|
|
for (const r of toUnbind) {
|
|
const parsed = parseRelease(r.title, r.subtitle ? { subtitle: r.subtitle } : {});
|
|
await q(
|
|
`update source_release set media_entity_id = null, content_unit_id = null, resolution_status = 'unresolved',
|
|
resolution_evidence = $2::jsonb, updated_at = now()
|
|
where id = $1 and not resolution_locked`,
|
|
[r.id, JSON.stringify({ reason: "rollback_wrong_alias", previousEntityId: r.entityId })],
|
|
);
|
|
const normalized = parsed.title ? normalizeTitle(parsed.title) || null : null;
|
|
await q(
|
|
`insert into identity_candidate (source_release_id, status, reason, query, normalized_title, candidates,
|
|
evidence_version, attempts, last_attempt_at, next_review_at)
|
|
values ($1, 'pending', 'no_match', $2::jsonb, $3, '[]'::jsonb, 'rollback', 0, now(), now())
|
|
on conflict (source_release_id) do update set status = 'pending', reason = 'no_match', attempts = 0,
|
|
next_review_at = now(), resolved_media_entity_id = null, resolved_by = null, resolved_at = null`,
|
|
[r.id, JSON.stringify({ title: parsed.title ?? null, rollbackFrom: r.entityId }), normalized],
|
|
);
|
|
await q(
|
|
`insert into resolution_attempt (source_release_id, outcome, reason, evidence_version, candidate_count,
|
|
media_entity_id, actor_type, actor_id)
|
|
values ($1, 'manual', 'rollback_wrong_alias', 'rollback', 0, null, 'system', 'identity-reevaluate')`,
|
|
[r.id],
|
|
);
|
|
}
|
|
await db.query("commit");
|
|
console.log("已执行:资源退回待识别池并排入立即复查(由运行中的服务按新规则重新识别)");
|
|
} catch (e) {
|
|
await db.query("rollback");
|
|
throw e;
|
|
}
|
|
}
|
|
const orphan = await q<{ n: number }>(
|
|
`select count(*)::int as n from content_unit u
|
|
where u.media_entity_id = any($1::uuid[])
|
|
and not exists (select 1 from source_release r where r.content_unit_id = u.id)`,
|
|
[entities],
|
|
).catch(() => [{ n: -1 }]);
|
|
if (orphan[0] && orphan[0].n > 0)
|
|
console.log(
|
|
`提示:这些作品下${APPLY ? "现在" : "当前"}有 ${orphan[0].n} 个内容单元没有资源引用(脚本不删除,需要时人工清理)`,
|
|
);
|
|
}
|
|
|
|
if (!APPLY) console.log("\n(dry-run:未改库;确认后加 --apply 执行)");
|
|
await db.end();
|