Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

feat(media): 统一资料补全与本地视频预览任务

longmeidao9e48551e992e
diff --git a/src/peach/library_processing.py b/src/peach/library_processing.py
index fb3dc3f49..51326dbed 100644
--- a/src/peach/library_processing.py
+++ b/src/peach/library_processing.py
@@ -5,6 +5,8 @@ import hashlib
import io
import json
import sqlite3
+import subprocess
+import tempfile
import time
import uuid
import xml.etree.ElementTree as ET
@@ -44,9 +46,10 @@ LABELS = dict(title='标题', original_title='原标题', performers='演员', s
#: 状态里最多保留这么多条问题;完整问题写在任务专属 JSONL 里,接口分页读取。
ISSUE_PREVIEW_LIMIT = 20
-#: 这条链能分开跑的两段,和一次跑完。名字进接口也进页面,改这里就是改契约。
+#: 扫描、资料与预览共用的阶段名,同时用于接口和页面。
SCAN_STAGE, COLLECT_STAGE, ALL_STAGES = 'scan', 'collect', 'all'
-STAGES = (ALL_STAGES, SCAN_STAGE, COLLECT_STAGE)
+METADATA_STAGE, PREVIEWS_STAGE = 'metadata', 'previews'
+STAGES = (ALL_STAGES, SCAN_STAGE, COLLECT_STAGE, METADATA_STAGE, PREVIEWS_STAGE)
#: 没有动作截止时间的阶段(本地读取)超过这么久没有心跳就在页面上预警。
STALL_AFTER_SECONDS = 120.0
@@ -1575,13 +1578,14 @@ def _chosen_asset_paths(db_path, asset_ids):
def _online_source_root(source, root, chosen_paths, *, retrying, issue):
translated_root = translate_ledger_path(root)
- if root_online(translated_root):
- return translated_root
relevant = not retrying or any(
path.is_relative_to(translated_root)
for path in chosen_paths.get(source, ()))
- if relevant:
- issue(None, f'{source} 来源离线', action='reading_local')
+ if not relevant:
+ return None
+ if root_online(translated_root):
+ return translated_root
+ issue(None, f'{source} 来源离线', action='reading_local')
return None
@@ -1618,39 +1622,147 @@ def _finish_collection(config, database, candidate_root, cover_root, groups, rem
performer_profile_failed=profiles['failed'])
+def _asset_selection(db_path, asset_ids):
+ """显式选择只接受仍在馆藏中的视频;空选择不能解释成全库。"""
+ if asset_ids is None:
+ return None
+ if not isinstance(asset_ids, list) or not asset_ids or any(
+ type(value) is not int or value <= 0 for value in asset_ids):
+ raise ValueError('请选择有效的视频项目')
+ chosen = list(dict.fromkeys(asset_ids))
+ marks = ','.join('?' * len(chosen))
+ with closing(sqlite3.connect(db_path, timeout=30)) as connection:
+ found = {row[0] for row in connection.execute(
+ f"SELECT id FROM asset WHERE id IN ({marks}) AND medium='video' AND disposal IS NULL", chosen)}
+ if found != set(chosen):
+ raise ValueError('所选视频已不存在或已移入回收站,请刷新后重试')
+ return chosen
+
+
+def _generate_preview(config, row, database, resolver, *, progress):
+ """复用九宫格抽帧原语,产物可用后在共享写锁内登记。"""
+ from . import frame_capture, media_probe
+ from .fsutil import atomic_path
+
+ root = (config.directory('generated') / 'snapshots').resolve()
+ previous = row.get('snapshot_path')
+ if previous:
+ previous = translate_ledger_path(previous)
+ if previous.is_relative_to(root) and measure_image_file(previous):
+ return False
+ choice = resolver.ffmpeg()
+ if choice is None:
+ raise ValueError('未找到 FFmpeg,无法生成预览图,请在诊断页检查工具状态')
+ video = translate_ledger_path(row['path'])
+ if not video.is_file():
+ raise ValueError('媒体文件不可访问')
+ duration = row.get('duration') or 0
+ if duration <= 0:
+ probe = resolver.ffprobe()
+ if probe is None:
+ raise ValueError('未找到 ffprobe,无法读取视频时长')
+ measured = media_probe.measure(str(probe.path), row['id'], str(video))
+ duration = measured[0]
+ if duration <= 0:
+ raise ValueError('视频时长未取得,请检查媒体文件后重试')
+ progress()
+ with database.write_transaction() as connection:
+ connection.execute(media_probe.UPDATE, measured)
+ digest = hashlib.sha1(str(row['path']).encode('utf-8')).hexdigest()[:16]
+ destination = root / 'local' / digest[:2] / (digest + '.jpg')
+ if not measure_image_file(destination):
+ with tempfile.TemporaryDirectory(prefix='peach-preview-') as temporary:
+ frames = Path(temporary)
+ for index in range(9):
+ progress()
+ timestamp = duration * (0.03 + 0.94 * (index + 0.5) / 9)
+ if not frame_capture.capture_with_retry(
+ str(choice.path), str(video), timestamp, frames / f's{index:02d}.jpg'):
+ raise ValueError('视频抽帧未取得,请检查媒体文件后重试')
+ progress()
+ with atomic_path(destination) as output:
+ if not frame_capture.tile_frames(str(choice.path), str(frames / 's%02d.jpg'), 3, 3, output):
+ raise ValueError('预览图未生成,请检查媒体文件后重试')
+ if not measure_image_file(output):
+ raise ValueError('预览图无法读取,请重试')
+ progress()
+ with database.write_transaction() as connection:
+ result = connection.execute(
+ "UPDATE asset SET snapshot_path=? WHERE id=? AND path=? AND location='local' "
+ "AND medium='video' AND disposal IS NULL", (str(destination), row['id'], row['path']))
+ return bool(result.rowcount)
+
+
+def _generate_previews(config, rows, database, *, update, issue, guard):
+ """只读本机视频;来源失败与抽帧失败各自保留可重试项目。"""
+ if database is None:
+ return 0
+ rows = [row for row in rows if row['location'] == 'local']
+ resolver = FFmpegResolver(config.directory('tools') / 'ffmpeg')
+ made = 0
+ for index, row in enumerate(rows):
+ def progress(row=row, index=index, made=made):
+ guard.check()
+ update(stage='生成预览图', checked=index, total=len(rows), previews=made,
+ current_asset_id=row['id'], current_asset_name=Path(str(row['name'] or '')).name,
+ current_action='generating_preview', current_started_at=time.time(),
+ current_deadline_at=time.time() + 90)
+ progress()
+ try:
+ made += int(_generate_preview(config, row, database, resolver, progress=progress))
+ except InterruptedError:
+ raise
+ except (OSError, ValueError, subprocess.SubprocessError) as error:
+ message = (str(error) if isinstance(error, ValueError) else
+ '生成预览图超时,请重试' if isinstance(error, subprocess.SubprocessError) else
+ '生成预览图失败,请检查 FFmpeg 与目录权限后重试')
+ issue(row, message, action='generating_preview', retryable=True)
+ update(checked=index + 1, previews=made, current_asset_id=None, current_asset_name='',
+ current_action='', current_started_at=None, current_deadline_at=None)
+ return made
+
+
def process_library(config, db_path, candidate_root, cover_root, *, location='configured',
report=lambda state: None, provider_factory=None, job_id=None,
retry_ids=None, active=lambda: True, stage=ALL_STAGES,
- database=None, route_overrides=None, state_file=None):
+ database=None, route_overrides=None, state_file=None, asset_ids=None):
"""登记文件与确定的番号,外部资料保留为可复核候选。
`retry_ids` 为 `None` 时处理整个馆藏;给定时只处理这些项目(上一任务记录的
可重试失败),不重新扫描来源目录,已有候选与封面照常复用。
- `stage` 把这条链分两段跑:`scan` 只走一遍来源目录把文件登记进馆藏,`collect`
- 跳过那一遍、直接读本地资料并采集缺失的。新盘刚接上时要的是前者——几万个
- 文件登记完就能用,不必等采集;采集被网络拖住时要的是后者,重跑不必再扫一遍
- 磁盘。缺省两段都跑。
+ `stage` 指定处理范围:`all` 扫描并补全资料与本地预览,`scan` 只扫描,
+ `collect` 补全资料与本地预览,`metadata` 只采集资料,`previews` 只生成本地预览。
+ `asset_ids` 指定仍在馆藏中的视频,不扫描来源目录;空选择无效。
`database` 是调用方已经在用的 `LedgerDatabase`。给了它才做收尾的自动落库与人物
- 资料补齐,并且与调用方共用同一把进程内写锁;不给就只采集候选。
+ 资料补齐与本地预览登记,并且与调用方共用同一把进程内写锁;不给就只采集候选。
`route_overrides` 覆盖某几种内容类型的来源链,形状与判据见
`metadata_routes.parse_route_overrides`;不给就用内建那张表。
`state_file` 给后台定向任务保存独立进度,共享候选写入仍使用全库处理锁。
"""
_require_writer(config, db_path)
+ if stage not in STAGES:
+ raise ValueError('处理阶段无效')
+ if asset_ids is not None and retry_ids is not None:
+ raise ValueError('选择项目与失败重试不能同时使用')
+ selected_ids = _asset_selection(db_path, asset_ids)
+ if stage == PREVIEWS_STAGE and database is None:
+ raise ValueError('生成预览图需要共享馆藏写入连接')
routes = metadata_routes.parse_route_overrides(route_overrides)
path = Path(state_file) if state_file is not None else state_path(config)
path.parent.mkdir(parents=True, exist_ok=True)
retrying = retry_ids is not None
- chosen_ids = list(dict.fromkeys(map(int, retry_ids or [])))
- scope_ids = chosen_ids if retrying else None
+ targeted = retrying or selected_ids is not None
+ chosen_ids = selected_ids if selected_ids is not None else list(dict.fromkeys(map(int, retry_ids or [])))
+ scope_ids = chosen_ids if targeted else None
chosen_paths = _chosen_asset_paths(db_path, chosen_ids)
with FileLock(str(state_path(config)) + '.lock', timeout=0):
state = dict(job_id=job_id or uuid.uuid4().hex, status='running',
stage='读取本地资料' if retrying else '扫描文件',
- checked=0, total=0, scanned=0, probed=0, identified=0, candidates=0, covers=0,
+ checked=0, total=0, scanned=0, probed=0, identified=0, candidates=0, covers=0, previews=0,
+ requested_stage=stage, asset_ids=scope_ids,
issue_count=0, paused_count=0, issue_preview=[], issues_truncated=False,
notes={}, retryable_asset_ids=[],
last_progress_at=time.time(), progress_seq=0,
@@ -1717,14 +1829,16 @@ def process_library(config, db_path, candidate_root, cover_root, *, location='co
ffprobe = _ffprobe_path(config)
online_roots = []
for source, roots in locations.items():
+ if stage == PREVIEWS_STAGE and source != 'local':
+ continue
for root in roots:
guard.check()
translated_root = _online_source_root(
- source, root, chosen_paths, retrying=retrying, issue=issue)
+ source, root, chosen_paths, retrying=targeted, issue=issue)
if translated_root is None:
continue
online_roots.append(translated_root)
- if not retrying and stage != COLLECT_STAGE:
+ if not targeted and stage in (ALL_STAGES, SCAN_STAGE):
result = scan_location(db_path, source, root, declared_roots=config.locations,
mounts=mounts, report=lambda line: update(stage='扫描文件'))
state['scanned'] += result.files
@@ -1749,7 +1863,7 @@ def process_library(config, db_path, candidate_root, cover_root, *, location='co
" WHERE asset_entity.asset_id=asset.id AND entity.kind='performer') AS performers,"
" (SELECT group_concat(asset_tag.tag) FROM asset_tag"
" WHERE asset_tag.asset_id=asset.id AND asset_tag.tag NOT LIKE '演员:%') AS tags")
- if retrying:
+ if targeted:
placeholders = ','.join('?' * len(chosen_ids))
query = (f"SELECT asset.*, {multi} FROM asset WHERE id IN ({placeholders}) AND medium='video' "
"AND disposal IS NULL ORDER BY id")
@@ -1767,6 +1881,12 @@ def process_library(config, db_path, candidate_root, cover_root, *, location='co
and any(translate_ledger_path(row['path']).is_relative_to(root) for root in online_roots)]
# 用户在复核页收录过的 genre 从这一批起就是已知词,不该再作为未收录回来问一遍。
genre_decisions = load_genre_decisions(connection)
+ if stage in (ALL_STAGES, COLLECT_STAGE, PREVIEWS_STAGE):
+ _generate_previews(config, rows, database, update=update, issue=issue, guard=guard)
+ if stage == PREVIEWS_STAGE:
+ update(status='failed' if state['issue_count'] else 'complete', stage='处理结束',
+ completed_at=time.time(), error=issue_summary(state['issue_count'], state['paused_count']))
+ return state
output = candidate_root / 'library-metadata-field-candidates.csv'
groups = {row['item_key']: row for row in read_rows(output, missing_ok=True)}
scoped_groups = lambda: _candidate_scope(groups, scope_ids)
diff --git a/src/peach/web_library_processing.py b/src/peach/web_library_processing.py
index 6a72c8d19..dd447a054 100644
--- a/src/peach/web_library_processing.py
+++ b/src/peach/web_library_processing.py
@@ -3,6 +3,7 @@ import json
from . import settings_file
from .library_processing import (ALL_STAGES, COLLECT_STAGE, SCAN_STAGE, STAGES,
+ METADATA_STAGE, PREVIEWS_STAGE, _asset_selection,
decorate, issues_path, process_library, snapshot)
@@ -76,7 +77,13 @@ def w_library_processing(contract, body):
if previous.get('status') == 'running':
return previous
retry_ids = _retry_ids(previous, body)
- stage = str((body or {}).get('stage') or ALL_STAGES)
+ if 'asset_ids' in (body or {}) and body['asset_ids'] is None:
+ raise ValueError('请选择有效的视频项目')
+ asset_ids = _asset_selection(contract.db_path, (body or {}).get('asset_ids'))
+ if asset_ids is not None and retry_ids is not None:
+ raise ValueError('选择项目与失败重试不能同时使用')
+ stage = str((body or {}).get('stage') or
+ (previous.get('requested_stage') if retry_ids is not None else None) or ALL_STAGES)
if stage not in STAGES:
raise ValueError('处理阶段无效')
if retry_ids is not None and not retry_ids:
@@ -84,7 +91,7 @@ def w_library_processing(contract, body):
def work(job_id):
try:
result = process_library(config, contract.db_path, contract.candidate_root, contract.cover_root,
- job_id=job_id, retry_ids=retry_ids, stage=stage,
+ job_id=job_id, retry_ids=retry_ids, stage=stage, asset_ids=asset_ids,
# 自动落库与页面写的是同一个 `LedgerDatabase`:进程内写锁在实例上,
# 另建一个就是在同一个进程里开第二条写入路径。
database=contract.database,
@@ -96,6 +103,7 @@ def w_library_processing(contract, body):
contract.cache_bust()
# 起步那行字按这一趟真正要做的事写:点了「只扫描」却看到「读取本地资料」,
# 人会以为点错了。
- labels = {ALL_STAGES: '准备处理', SCAN_STAGE: '准备扫描文件', COLLECT_STAGE: '准备采集资料'}
+ labels = {ALL_STAGES: '准备处理', SCAN_STAGE: '准备扫描文件', COLLECT_STAGE: '准备采集资料',
+ METADATA_STAGE: '准备采集资料', PREVIEWS_STAGE: '准备生成预览图'}
return contract.library_processing_job.start(
work, restart=True, initial={'stage': labels[stage], 'requested_stage': stage})
diff --git a/tests/test_metadata_library.py b/tests/test_metadata_library.py
index cab816e91..20afef5b6 100644
--- a/tests/test_metadata_library.py
+++ b/tests/test_metadata_library.py
@@ -373,7 +373,8 @@ class LibraryNfoTests(unittest.TestCase):
}
provider.cover.return_value = False
- with patch('peach.avatar_provider.FaceProbe') as face:
+ with patch('peach.avatar_provider.FaceProbe') as face, \
+ patch('peach.library_processing._generate_previews', return_value=0):
face.return_value.return_value = None
result = process_library(
config, db, self.root / 'generated', self.root / 'covers',
@@ -2230,3 +2231,205 @@ class LibraryWatchdogTests(unittest.TestCase):
timeout = transport.call_args.args[1]
self.assertGreater(timeout, 4)
self.assertLessEqual(timeout, 5)
+
+
+class LibraryPreviewCompletionTests(unittest.TestCase):
+ def setUp(self):
+ temporary = tempfile.TemporaryDirectory()
+ self.addCleanup(temporary.cleanup)
+ self.root = Path(temporary.name).resolve()
+ self.media = self.root / 'media'
+ self.media.mkdir()
+ self.config = PeachConfig(self.root, self.root / 'config.toml', present=True,
+ locations={'local': (str(self.media),),
+ 'pikpak': (str(self.root / 'unmounted-cloud'),)})
+ directory = self.root / 'database'
+ directory.mkdir()
+ self.db = fresh_ledger(directory)
+ self.database = LedgerDatabase(self.db)
+ self.resolver = Mock()
+ self.resolver.ffmpeg.return_value = SimpleNamespace(path=Path('test-ffmpeg'))
+ with self.database.write_transaction() as connection:
+ for aid, location, medium, disposal in ((1, 'local', 'video', None),
+ (2, 'pikpak', 'video', None),
+ (3, 'local', 'photo', None),
+ (4, 'local', 'video', 'trash')):
+ video = self.media / f'clip-{aid}.mp4'
+ video.write_bytes(b'video')
+ connection.execute(
+ 'INSERT INTO asset(id,location,path,name,medium,duration,disposal) VALUES(?,?,?,?,?,?,?)',
+ (aid, location, str(video), video.name, medium, 30, disposal))
+
+ def run_processing(self, **options):
+ return process_library(self.config, self.db, self.root / 'candidates', self.root / 'covers',
+ database=self.database, **options)
+
+ @staticmethod
+ def make_tile(_ffmpeg, _pattern, _columns, _rows, destination):
+ Image.new('RGB', (1440, 810), 'green').save(destination, format='JPEG')
+ return True
+
+ def test_selected_completion_generates_a_snapshot_without_scanning_or_cloud_reads(self):
+ reports = []
+ with patch('peach.library_processing.scan_location') as scan, \
+ patch('peach.library_processing.FFmpegResolver', return_value=self.resolver), \
+ patch('peach.frame_capture.capture_with_retry', return_value=True) as capture, \
+ patch('peach.frame_capture.tile_frames', side_effect=self.make_tile), \
+ patch('peach.library_processing._finish_collection', return_value={}), \
+ patch('peach.library_processing.root_online', return_value=True) as online:
+ result = self.run_processing(asset_ids=[1], report=reports.append)
+ scan.assert_not_called()
+ self.assertEqual(capture.call_count, 9)
+ online.assert_called_once_with(self.media)
+ self.assertEqual(result['status'], 'complete')
+ self.assertEqual(result['previews'], 1)
+ self.assertEqual(result['requested_stage'], 'all')
+ self.assertEqual(result['asset_ids'], [1])
+ self.assertTrue(any(row.get('current_action') == 'generating_preview' for row in reports))
+ with self.database.read_connection() as connection:
+ snapshot = connection.execute('SELECT snapshot_path FROM asset WHERE id=1').fetchone()[0]
+ self.assertIsNone(connection.execute('SELECT snapshot_path FROM asset WHERE id=2').fetchone()[0])
+ self.assertTrue(Path(snapshot).is_relative_to(self.root / 'generated' / 'snapshots'))
+ self.assertTrue(Path(snapshot).is_file())
+ with patch('peach.frame_capture.capture_with_retry') as capture:
+ second = self.run_processing(stage='previews')
+ self.assertEqual(second['previews'], 0)
+ self.assertEqual(second['status'], 'complete')
+ capture.assert_not_called()
+
+ def test_preview_only_leaves_candidates_and_sources_untouched(self):
+ factory = Mock(side_effect=AssertionError('外部资料不属于预览任务'))
+ with patch('peach.library_processing.FFmpegResolver', return_value=self.resolver), \
+ patch('peach.frame_capture.capture_with_retry', return_value=True), \
+ patch('peach.frame_capture.tile_frames', side_effect=self.make_tile), \
+ patch('peach.library_processing._finish_collection') as finish:
+ result = self.run_processing(stage='previews', provider_factory=factory)
+ self.assertEqual(result['total'], 1)
+ self.assertEqual(result['previews'], 1)
+ self.assertFalse((self.root / 'candidates').exists())
+ finish.assert_not_called()
+ factory.assert_not_called()
+
+ def test_missing_ffmpeg_is_retryable_and_collection_can_finish_its_work(self):
+ self.resolver.ffmpeg.return_value = None
+ with patch('peach.library_processing.FFmpegResolver', return_value=self.resolver), \
+ patch('peach.library_processing._finish_collection', return_value={'auto_applied': 2}) as finish:
+ result = self.run_processing(stage='collect', asset_ids=[1])
+ finish.assert_called_once()
+ self.assertEqual(result['auto_applied'], 2)
+ self.assertEqual(result['status'], 'failed')
+ self.assertEqual(result['retryable_asset_ids'], [1])
+ issue = json.loads(Path(result['issues_log']).read_text(encoding='utf-8').splitlines()[0])
+ self.assertEqual(issue['failed_action'], 'generating_preview')
+ self.assertIn('FFmpeg', result['issue_preview'][0]['message'])
+
+ def test_metadata_only_never_extracts_frames(self):
+ with patch('peach.library_processing._generate_previews') as generate, \
+ patch('peach.library_processing._finish_collection', return_value={}):
+ result = self.run_processing(stage='metadata', asset_ids=[1])
+ generate.assert_not_called()
+ self.assertEqual(result['previews'], 0)
+ self.assertEqual(result['status'], 'complete')
+
+ def test_local_preview_is_available_when_online_collection_starts(self):
+ with self.database.write_transaction() as connection:
+ connection.execute("UPDATE asset SET code='ABW-358' WHERE id=1")
+ def collect(*_args, **_kwargs):
+ with self.database.read_connection() as connection:
+ path = connection.execute('SELECT snapshot_path FROM asset WHERE id=1').fetchone()[0]
+ self.assertTrue(Path(path).is_file())
+ return [], 0
+ with patch('peach.library_processing.FFmpegResolver', return_value=self.resolver), \
+ patch('peach.frame_capture.capture_with_retry', return_value=True), \
+ patch('peach.frame_capture.tile_frames', side_effect=self.make_tile), \
+ patch('peach.library_processing._RemoteSession.collect', side_effect=collect) as online, \
+ patch('peach.library_processing._finish_collection', return_value={}):
+ result = self.run_processing(stage='collect', asset_ids=[1])
+ online.assert_called_once()
+ self.assertEqual(result['previews'], 1)
+
+ def test_failed_tiling_leaves_no_registered_or_partial_snapshot(self):
+ import subprocess
+ with patch('peach.library_processing.FFmpegResolver', return_value=self.resolver), \
+ patch('peach.frame_capture.capture_with_retry', return_value=True), \
+ patch('peach.frame_capture.tile_frames', side_effect=subprocess.TimeoutExpired('ffmpeg', 60)):
+ result = self.run_processing(stage='previews')
+ self.assertEqual(result['status'], 'failed')
+ self.assertEqual(result['retryable_asset_ids'], [1])
+ self.assertIn('超时', result['issue_preview'][0]['message'])
+ self.assertFalse(list((self.root / 'generated').rglob('*.jpg')))
+ with self.database.read_connection() as connection:
+ self.assertIsNone(connection.execute('SELECT snapshot_path FROM asset WHERE id=1').fetchone()[0])
+
+ def test_selected_assets_require_active_videos(self):
+ for selection in ([], [True], [0], [-1], ['1'], '1', [99], [3], [4]):
+ with self.subTest(selection=selection), self.assertRaises(ValueError), \
+ patch('peach.library_processing.scan_location') as scan:
+ self.run_processing(asset_ids=selection)
+ scan.assert_not_called()
+ with self.assertRaises(ValueError):
+ self.run_processing(asset_ids=[1], retry_ids=[1])
+
+ def test_stop_during_extraction_registers_no_snapshot(self):
+ alive = [True]
+ def capture(*_args, **_kwargs):
+ alive[0] = False
+ return True
+ with patch('peach.library_processing.FFmpegResolver', return_value=self.resolver), \
+ patch('peach.frame_capture.capture_with_retry', side_effect=capture), \
+ self.assertRaises(InterruptedError):
+ self.run_processing(stage='previews', active=lambda: alive[0])
+ with self.database.read_connection() as connection:
+ self.assertIsNone(connection.execute('SELECT snapshot_path FROM asset WHERE id=1').fetchone()[0])
+ self.assertFalse(list((self.root / 'generated').rglob('*.jpg')))
+
+ def test_web_request_preserves_preview_scope_when_retrying(self):
+ from peach.web_library_processing import w_library_processing
+ previous = {'job_id': 'old', 'status': 'failed', 'requested_stage': 'previews',
+ 'retryable_asset_ids': [1]}
+ job = SimpleNamespace(snapshot=lambda: None, update=lambda *_args, **_kwargs: None,
+ start=lambda work, restart, initial: (work('new'), initial)[1])
+ contract = SimpleNamespace(db_path=self.db, database=self.database,
+ candidate_root=self.root / 'candidates', cover_root=self.root / 'covers',
+ library_processing_job=job, cache_bust=lambda: None)
+ with patch('peach.web_library_processing.settings_file.active', return_value=self.config), \
+ patch('peach.web_library_processing.snapshot', return_value=previous), \
+ patch('peach.web_library_processing.process_library', return_value={'status': 'complete'}) as run:
+ result = w_library_processing(contract, {'job_id': 'old', 'retry': []})
+ self.assertEqual(result['requested_stage'], 'previews')
+ self.assertEqual(run.call_args.kwargs['stage'], 'previews')
+ self.assertEqual(run.call_args.kwargs['retry_ids'], [1])
+ w_library_processing(contract, {'stage': 'collect', 'asset_ids': [1, 1]})
+ self.assertEqual(run.call_args.kwargs['asset_ids'], [1])
+ for selection in ([], None, [99], [True]):
+ with self.subTest(selection=selection), self.assertRaises(ValueError):
+ w_library_processing(contract, {'asset_ids': selection})
+
+ def test_real_local_video_produces_a_snapshot_and_card_poster(self):
+ import subprocess
+ from peach.ffmpeg import FFmpegResolver
+ from peach.previews import PreviewService
+ from peach.repository import LedgerRepository
+ resolver = FFmpegResolver(self.config.directory('tools') / 'ffmpeg')
+ choice = resolver.ffmpeg()
+ if choice is None or resolver.ffprobe() is None:
+ self.skipTest('需要 FFmpeg 和 ffprobe')
+ video = self.media / 'clip-1.mp4'
+ subprocess.run([str(choice.path), '-y', '-v', 'error', '-f', 'lavfi',
+ '-i', 'testsrc2=size=320x180:rate=10', '-t', '3', '-an',
+ '-c:v', 'mpeg4', str(video)], capture_output=True, check=True, timeout=30)
+ with self.database.write_transaction() as connection:
+ connection.execute('UPDATE asset SET duration=NULL WHERE id=1')
+ result = self.run_processing(stage='previews')
+ self.assertEqual(result['status'], 'complete')
+ self.assertEqual(result['previews'], 1)
+ with self.database.read_connection() as connection:
+ row = connection.execute('SELECT snapshot_path,duration FROM asset WHERE id=1').fetchone()
+ self.assertGreater(row['duration'], 0)
+ with Image.open(row['snapshot_path']) as image:
+ self.assertEqual(image.size, (1440, 810))
+ generated = self.root / 'generated'
+ service = PreviewService(LedgerRepository(self.database), resolver, generated / 'snapshots',
+ generated / 'posters', generated / 'avatars', generated / 'logos')
+ with Image.open(service.poster(1)) as image:
+ self.assertEqual(image.size, (480, 270))