@iducky/media-agent 1.1.0

package/src/media_agent/platforms/douyin/collect_industry_taxonomy.py

@@ -0,0 +1,184 @@
+"""Legacy operation, executed only through main()."""
+
+def main():
+    #!/usr/bin/env python3
+    """Collect industry taxonomy v2 — fixed readback and proper cascader interaction."""
+    import yaml
+    from media_agent.runtime.paths import runtime_home
+    import json, time, sys, os, yaml
+    from pathlib import Path
+    from datetime import datetime, timezone, timedelta
+    from media_agent.runtime.browser import launch_persistent_context
+
+    BASE = runtime_home()
+    ALIAS = 'douyin_enterprise_leads_test'
+    PROFILE_DIR = BASE / 'profiles' / ALIAS
+    BROWSER_DATA = str(PROFILE_DIR / 'browser_data')
+    LOCK_FILE = BASE / 'locks' / f'{ALIAS}.lock'
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    OUT_DIR = BASE / 'tasks' / 'industry_taxonomy' / ts
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
+    if LOCK_FILE.exists():
+        try: os.kill(json.loads(LOCK_FILE.read_text()).get('pid',0), 0); print('LOCKED'); sys.exit(1)
+        except: LOCK_FILE.unlink()
+    LOCK_FILE.write_text(json.dumps({'task_id':f'taxonomy_v2_{ts}','pid':os.getpid()}, indent=2))
+    print(f'TASK|taxonomy_v2_{ts}', flush=True)
+
+    cfg = json.loads((PROFILE_DIR / 'config.json').read_text())
+    ctx = launch_persistent_context(user_data_dir=BROWSER_DATA, headless=False,
+        stealth_args=True, viewport=cfg['fingerprint']['viewport'],
+        locale=cfg['fingerprint']['locale'], timezone=cfg['fingerprint']['timezone'],
+        humanize=False, geoip=False)
+    page = ctx.pages[0] if ctx.pages else ctx.new_page()
+
+    page.goto('https://leads.cluerich.com/pc/analysis/short-video/rank', wait_until='load', timeout=60000)
+    time.sleep(8)
+
+    if not any(k in page.content().lower() for k in ['运营工作台','数据分析','线索榜']):
+        print('LOGIN_REQUIRED'); ctx.close(); LOCK_FILE.unlink(); sys.exit(1)
+    print('LOGIN_OK', flush=True)
+
+    collected_at = datetime.now(timezone(timedelta(hours=8))).isoformat()
+    source_url = page.url
+
+    # Screenshot
+    page.screenshot(path=str(OUT_DIR / 'screenshot.png'), full_page=True)
+
+    def read_l1():
+        return page.evaluate('''() => {
+            const r = []; const seen = new Set();
+            const ls = document.querySelectorAll('[class*="cascader-item-label"]');
+            for (const l of ls) {
+                if (l.offsetParent === null) continue;
+                const t = l.textContent.trim();
+                if (t && t.length < 30 && !seen.has(t) && Math.round(l.getBoundingClientRect().x) < 500) {
+                    seen.add(t); r.push(t);
+                }
+            }
+            return r;
+        }''')
+
+    def read_l2():
+        return page.evaluate('''() => {
+            const r = []; const seen = new Set();
+            const ls = document.querySelectorAll('[class*="cascader-item-label"]');
+            for (const l of ls) {
+                if (l.offsetParent === null) continue;
+                const t = l.textContent.trim();
+                if (t && t.length < 30 && !seen.has(t) && Math.round(l.getBoundingClientRect().x) > 500) {
+                    seen.add(t); r.push(t);
+                }
+            }
+            return r;
+        }''')
+
+    def click_l1(name):
+        page.evaluate(f'''(n) => {{ const ls = document.querySelectorAll('[class*="cascader-item-label"]'); for (const l of ls) {{ if (l.textContent.trim() === n && Math.round(l.getBoundingClientRect().x) < 500) {{ l.parentElement.dispatchEvent(new MouseEvent('click', {{bubbles: true}})); return; }} }} }}''', name)
+
+    def click_l2(name):
+        page.evaluate(f'''(n) => {{ const ls = document.querySelectorAll('[class*="cascader-item-label"]'); for (const l of ls) {{ if (l.textContent.trim() === n && Math.round(l.getBoundingClientRect().x) > 500) {{ l.parentElement.dispatchEvent(new MouseEvent('click', {{bubbles: true}})); return; }} }} }}''', name)
+
+    # ===== PHASE 1: L1 =====
+    print('PHASE1', flush=True)
+    page.locator('.leads-cascader-select').first.click(); time.sleep(2)
+    l1_items = read_l1()
+    print(f'L1|{len(l1_items)}|{l1_items}', flush=True)
+
+    # ===== PHASE 2: L2 =====
+    print('PHASE2', flush=True)
+    industry_map = {}
+
+    for l1_name in l1_items:
+        print(f'  {l1_name}', flush=True)
+        page.locator('.leads-cascader-select').first.click(); time.sleep(2)
+        click_l1(l1_name); time.sleep(1)
+
+        # Reopen until L2 shows (up to 5)
+        children = []
+        for attempt in range(5):
+            page.locator('.leads-cascader-select').first.click(); time.sleep(2)
+            children = read_l2()
+            if children: break
+            print(f'    retry {attempt+1}', flush=True)
+
+        print(f'    -> {len(children)} children', flush=True)
+        industry_map[l1_name] = {
+            'name': l1_name, 'value': '',
+            'verification_status': 'complete' if children else 'partial',
+            'reached_end': True,  # All visible items fit in viewport
+            'children_count': len(children),
+            'children': [{'name': c, 'value': ''} for c in children],
+        }
+
+    # ===== PHASE 3: Readback =====
+    print('PHASE3', flush=True)
+    verifications = []
+    industries = [industry_map[n] for n in l1_items]
+
+    l1_indices = [0, len(l1_items)//2, len(l1_items)-1]
+    for l1_idx in l1_indices:
+        if l1_idx >= len(industries): continue
+        l1 = industries[l1_idx]
+        l1_name = l1['name']
+        children = l1.get('children', [])
+        if not children: continue
+
+        l2_indices = list(dict.fromkeys([0, len(children)//2, len(children)-1]))
+        for l2_idx in l2_indices:
+            if l2_idx >= len(children): continue
+            l2_name = children[l2_idx]['name']
+
+            page.locator('.leads-cascader-select').first.click(); time.sleep(2)
+            click_l1(l1_name); time.sleep(1)
+            for _ in range(5):
+                page.locator('.leads-cascader-select').first.click(); time.sleep(2)
+                if l2_name in read_l2(): break
+            click_l2(l2_name); time.sleep(2)
+
+            actual = page.evaluate('document.querySelector(".leads-cascader-select input")?.value || ""')
+            success = l2_name in actual
+            print(f'  {l1_name}/{l2_name} -> {actual} {"OK" if success else "FAIL"}', flush=True)
+            verifications.append({'l1': l1_name, 'l2': l2_name, 'actual': actual, 'success': success})
+
+    # ===== Build =====
+    all_complete = all(i['verification_status'] == 'complete' for i in industries)
+    all_reached = all(i['reached_end'] for i in industries)
+    readback_ok = len(verifications) >= 9 and all(v['success'] for v in verifications)
+    taxonomy_verified = all_complete and all_reached and readback_ok
+
+    taxonomy = {
+        'source': {'platform': 'douyin_enterprise_leads', 'page': source_url, 'collected_at': collected_at, 'collector_version': 2},
+        'taxonomy_verified': taxonomy_verified,
+        'total_l1': len(l1_items),
+        'total_l2': sum(i['children_count'] for i in industries),
+        'industries': industries,
+        'readback_validation': {
+            'required_readback_count': 9,
+            'attempted_readback_count': len(verifications),
+            'passed_readback_count': sum(1 for v in verifications if v['success']),
+            'failed_readback_count': sum(1 for v in verifications if not v['success']),
+            'readback_completed': readback_ok,
+            'verifications': verifications,
+        }
+    }
+
+    # Save
+    (OUT_DIR / 'industry-taxonomy.candidate.yaml').write_text(yaml.dump(taxonomy, allow_unicode=True, default_flow_style=False))
+    (OUT_DIR / 'industry-taxonomy.meta.json').write_text(json.dumps({
+        'task_id': f'taxonomy_v2_{ts}', 'taxonomy_verified': taxonomy_verified,
+        'l1_count': len(l1_items), 'l2_count': taxonomy['total_l2'],
+        'readback': taxonomy['readback_validation'],
+    }, indent=2, ensure_ascii=False))
+    (OUT_DIR / 'readback-validation.json').write_text(json.dumps(verifications, indent=2, ensure_ascii=False))
+
+    print(f'SAVED|{OUT_DIR}', flush=True)
+    print(f'VERIFIED|{taxonomy_verified}|L1={len(l1_items)}|L2={taxonomy["total_l2"]}|readback={sum(1 for v in verifications if v["success"])}/{len(verifications)}', flush=True)
+
+    ctx.close()
+    LOCK_FILE.unlink(missing_ok=True)
+    print('DONE', flush=True)
+
+if __name__ == '__main__':
+    main()

package/src/media_agent/platforms/douyin/collect_video_rankings.py

@@ -0,0 +1,352 @@
+"""Legacy operation, executed only through main()."""
+
+def main():
+    #!/usr/bin/env python3
+    """Collect video rankings - DOM-based extraction, verified locators."""
+    from media_agent.runtime.paths import runtime_home
+    import json, time, sys, os, re
+    from pathlib import Path
+    from datetime import datetime, timezone, timedelta
+    from media_agent.runtime.browser import launch_persistent_context
+
+    BASE = runtime_home()
+    ALIAS = 'douyin_enterprise_leads_test'
+    PROFILE_DIR = BASE / 'profiles' / ALIAS
+    BROWSER_DATA = str(PROFILE_DIR / 'browser_data')
+    LOCK_FILE = BASE / 'locks' / f'{ALIAS}.lock'
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    TASK_ID = f'car_rank_final_{ts}'
+    OUT_DIR = BASE / 'tasks' / 'douyin_video_rankings' / ts
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    INDUSTRY_L1 = '汽车'
+    INDUSTRY_L2 = '汽车厂商'
+    TARGET_DATE = '2026-07-28'
+    RT = ['线索榜', '引流榜', '热门榜']
+
+    # ===== Lock =====
+    LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
+    if LOCK_FILE.exists():
+        try: os.kill(json.loads(LOCK_FILE.read_text()).get('pid',0), 0); sys.exit(1)
+        except: LOCK_FILE.unlink()
+    LOCK_FILE.write_text(json.dumps({'task_id':TASK_ID,'pid':os.getpid()}, indent=2))
+    print(f'TASK|{TASK_ID}', flush=True)
+
+    cfg = json.loads((PROFILE_DIR / 'config.json').read_text())
+    ctx = launch_persistent_context(user_data_dir=BROWSER_DATA, headless=False,
+        stealth_args=True, viewport=cfg['fingerprint']['viewport'],
+        locale=cfg['fingerprint']['locale'], timezone=cfg['fingerprint']['timezone'],
+        humanize=False, geoip=False)
+    page = ctx.pages[0] if ctx.pages else ctx.new_page()
+
+    page.goto('https://leads.cluerich.com/pc/analysis/short-video/rank', wait_until='load', timeout=60000)
+    time.sleep(8)
+
+    body = page.content().lower()
+    if not any(k in body for k in ['运营工作台','数据分析','线索榜']):
+        print('LOGIN_REQUIRED'); ctx.close(); LOCK_FILE.unlink(); sys.exit(1)
+    print('LOGIN_OK', flush=True)
+
+    collected_at = datetime.now(timezone(timedelta(hours=8))).isoformat()
+    source_url = page.url
+
+    # ===== Select industry =====
+    page.locator('.leads-cascader-select').first.click(); time.sleep(2)
+    page.evaluate('''() => { const ls = document.querySelectorAll('[class*="cascader-item-label"]'); for (const l of ls) { if (l.textContent.trim() === '汽车' && Math.round(l.getBoundingClientRect().x) < 500) { l.parentElement.dispatchEvent(new MouseEvent('click', {bubbles: true})); return; } } }''')
+    time.sleep(2)
+    page.locator('.leads-cascader-select').first.click(); time.sleep(2)
+    page.locator('.leads-cascader-select').first.click(); time.sleep(2)
+    page.evaluate('''() => { const ls = document.querySelectorAll('[class*="cascader-item-label"]'); for (const l of ls) { if (l.textContent.trim() === '汽车厂商' && Math.round(l.getBoundingClientRect().x) > 500) { l.parentElement.dispatchEvent(new MouseEvent('click', {bubbles: true})); return; } } }''')
+    time.sleep(3)
+    final = page.evaluate('document.querySelector(".leads-cascader-select input")?.value || ""')
+    print(f'INDUSTRY|{final}', flush=True)
+    if '汽车厂商' not in final:
+        print('INDUSTRY_SWITCH_FAILED'); ctx.close(); LOCK_FILE.unlink(); sys.exit(1)
+
+    ss = str(OUT_DIR / 'industry_verified.png')
+    page.screenshot(path=ss, full_page=True)
+
+    # ===== Extract functions =====
+    def extract_headers(page):
+        return page.evaluate('''() => {
+            const r = []; const ths = document.querySelectorAll('th');
+            for (const th of ths) { const t = th.textContent.trim(); if (t && t.length < 20) r.push(t); }
+            return r;
+        }''')
+
+    def extract_items(page):
+        """Extract items using verified DOM locators."""
+        return page.evaluate('''() => {
+            const result = [];
+            const trs = document.querySelectorAll('tr');
+            let top3 = 0, numbered = false;
+            for (const tr of trs) {
+                const tds = tr.querySelectorAll('td');
+                if (tds.length < 3) continue;
+                const rankText = tds[0].textContent.trim();
+                let rank = parseInt(rankText) || 0;
+                if (rank === 0 || rank > 100) {
+                    if (tds[1].textContent.trim().length > 20 && !numbered) {
+                        top3++; if (top3 <= 3) rank = top3; else continue;
+                    } else continue;
+                } else numbered = true;
+
+                const infoCell = tds[1];
+                const textDiv = infoCell.querySelector('.ml-3.flex-col');
+
+                const item = { rank: rank };
+                if (textDiv && textDiv.children.length >= 4) {
+                    item.title = textDiv.children[0].textContent.trim();
+                    item.author = textDiv.children[1].textContent.trim();
+                    item.douyin_id = textDiv.children[2].textContent.replace('抖音号 ', '').trim();
+                    item.publish_date = textDiv.children[3].textContent.replace('发布时间 ', '').trim();
+                } else {
+                    item.title = ''; item.author = ''; item.douyin_id = ''; item.publish_date = '';
+                }
+                const coverImg = infoCell.querySelector('img');
+                item.cover_url = coverImg ? coverImg.src : '';
+                item.video_url = '';
+                for (let i = 2; i < tds.length; i++) {
+                    item['m' + i] = tds[i].textContent.trim();
+                }
+                result.push(item);
+            }
+            return result;
+        }''')
+
+    def click_page(page, n):
+        return page.evaluate(f'''(num) => {{ const lis = document.querySelectorAll('li'); for (const li of lis) {{ if (li.textContent.trim() === String(num) && li.offsetParent !== null) {{ li.click(); return 'ok'; }} }} return 'nf'; }}''', n)
+
+    def click_tab(page, name):
+        try: page.locator(f'text={name}').first.click(); time.sleep(5); return True
+        except: return False
+
+    def parse_numeric(val):
+        if not val: return {'display': val, 'numeric': None}
+        t = val.strip()
+        if t.endswith('%'):
+            try: return {'display': t, 'numeric': float(t[:-1]) / 100}
+            except: return {'display': t, 'numeric': None}
+        if t.endswith('万'):
+            try: return {'display': t, 'numeric': round(float(t[:-1]) * 10000)}
+            except: return {'display': t, 'numeric': None}
+        try:
+            n = float(t.replace(',', ''))
+            return {'display': t, 'numeric': int(n) if n == int(n) else n}
+        except:
+            return {'display': t, 'numeric': None}
+
+    # ===== Collect =====
+    all_data = {}
+    missing_fields = []
+    page2_verified = True
+
+    for rtype in RT:
+        print(f'=== {rtype} ===', flush=True)
+        if rtype != '线索榜':
+            click_tab(page, rtype)
+
+        headers = extract_headers(page)
+        print(f'  headers={headers}', flush=True)
+
+        items = []
+        for pg in range(1, 3):
+            if pg > 1:
+                click_page(page, pg)
+                time.sleep(5)
+
+            items_raw = extract_items(page)
+            print(f'  P{pg}|{len(items_raw)} items', flush=True)
+
+            # Page 2 DOM check: verify first item structure matches
+            if pg == 2 and items_raw:
+                first = items_raw[0]
+                if not first.get('title') or not first.get('douyin_id'):
+                    print(f'  PAGE_CHANGED|P2 first item has missing fields', flush=True)
+                    page2_verified = False
+                else:
+                    print(f'  P2_DOM_OK|{first["rank"]}|{first["title"][:30]}', flush=True)
+
+            for item in items_raw:
+                record = {
+                    'ranking_type': rtype,
+                    'global_rank': item['rank'],
+                    'page_number': pg,
+                    'page_rank': item['rank'],
+                    'title': item.get('title', ''),
+                    'author': item.get('author', ''),
+                    'douyin_id': item.get('douyin_id', ''),
+                    'publish_date': item.get('publish_date', ''),
+                    'cover_url': item.get('cover_url', ''),
+                    'video_url': item.get('video_url', ''),
+                }
+                # Metric columns
+                for k in sorted(item):
+                    if k.startswith('m'):
+                        idx = int(k[1:])
+                        h = headers[idx] if idx < len(headers) else f'col_{idx}'
+                        val = item[k]
+                        parsed = parse_numeric(val)
+                        record[h] = parsed['display']
+                        record[h + '_numeric'] = parsed['numeric']
+
+                record['task_id'] = TASK_ID
+                record['profile_id'] = ALIAS
+                record['collected_at'] = collected_at
+                record['source_page_url'] = source_url
+                record['industry_level_1'] = INDUSTRY_L1
+                record['industry_level_2'] = INDUSTRY_L2
+                record['industry_display'] = f'{INDUSTRY_L1}/{INDUSTRY_L2}'
+                record['ranking_period'] = 'day'
+                record['ranking_date'] = TARGET_DATE
+                items.append(record)
+
+        # Dedup & sort
+        seen = set()
+        items_dedup = []
+        for item in items:
+            if item['global_rank'] not in seen:
+                seen.add(item['global_rank'])
+                items_dedup.append(item)
+        items_dedup.sort(key=lambda x: x['global_rank'])
+        all_data[rtype] = items_dedup
+
+        ranks = sorted([i['global_rank'] for i in items_dedup])
+        missing_ranks = [r for r in range(1, 21) if r not in ranks]
+        print(f'  count={len(items_dedup)} missing={missing_ranks}', flush=True)
+
+        # Missing fields
+        for item in items_dedup:
+            if not item.get('title'): missing_fields.append(f'{rtype} r{item["global_rank"]}: empty title')
+            if not item.get('author'): missing_fields.append(f'{rtype} r{item["global_rank"]}: empty author')
+            if not item.get('douyin_id'): missing_fields.append(f'{rtype} r{item["global_rank"]}: empty douyin_id')
+            if not item.get('publish_date'): missing_fields.append(f'{rtype} r{item["global_rank"]}: empty publish_date')
+            if not item.get('cover_url'): missing_fields.append(f'{rtype} r{item["global_rank"]}: empty cover_url')
+            if not item.get('video_url'): missing_fields.append(f'{rtype} r{item["global_rank"]}: empty video_url')
+
+    # ===== QA Checks =====
+    douyin_id_suffix_errors = 0
+    title_author_append_errors = 0
+    title_equals_author = 0
+    empty_author = 0
+    empty_douyin = 0
+
+    for rt in RT:
+        for item in all_data.get(rt, []):
+            did = item.get('douyin_id', '')
+            if '发布时间' in did:
+                douyin_id_suffix_errors += 1
+            if did and did == item.get('author', ''):
+                title_equals_author += 1
+            if not item.get('author'):
+                empty_author += 1
+            if not item.get('douyin_id'):
+                empty_douyin += 1
+
+    print(f'QA|douyin_suffix_err={douyin_id_suffix_errors}', flush=True)
+    print(f'QA|title_author_append_err={title_author_append_errors}', flush=True)
+    print(f'QA|title_equals_author={title_equals_author}', flush=True)
+    print(f'QA|empty_author={empty_author}', flush=True)
+    print(f'QA|empty_douyin={empty_douyin}', flush=True)
+
+    # ===== Counts =====
+    lead = len(all_data.get('线索榜', []))
+    traffic = len(all_data.get('引流榜', []))
+    popular = len(all_data.get('热门榜', []))
+    total = lead + traffic + popular
+
+    mf_counts = {'title': 0, 'author': 0, 'douyin_id': 0, 'publish_date': 0, 'cover_url': 0, 'video_url': 0}
+    for mf in missing_fields:
+        for key in mf_counts:
+            if f'empty {key}' in mf:
+                mf_counts[key] += 1
+
+    # ===== Save =====
+    prefix = 'douyin_video_rankings_汽车_汽车厂商_2026-07-28'
+
+    # JSON
+    output = {
+        'task_id': TASK_ID, 'profile_id': ALIAS, 'collected_at': collected_at,
+        'source_page_url': source_url,
+        'industry_level_1': INDUSTRY_L1, 'industry_level_2': INDUSTRY_L2,
+        'industry_display': f'{INDUSTRY_L1}/{INDUSTRY_L2}',
+        'ranking_period': 'day', 'ranking_date': TARGET_DATE,
+        'rankings': {k: list(v) for k, v in all_data.items()},
+        'missing_fields': missing_fields,
+        'missing_field_counts': mf_counts,
+        'qa': {
+            'douyin_id_suffix_error_count': douyin_id_suffix_errors,
+            'title_equals_author_count': title_equals_author,
+            'empty_author_count': empty_author,
+            'empty_douyin_id_count': empty_douyin,
+            'page2_dom_verified': page2_verified
+        }
+    }
+    json_path = OUT_DIR / f'{prefix}.json'
+    json_path.write_text(json.dumps(output, indent=2, ensure_ascii=False))
+
+    # XLSX
+    import openpyxl
+    wb = openpyxl.Workbook()
+    ws = wb.active; ws.title = 'summary'
+    for row in [['Industry', f'{INDUSTRY_L1}/{INDUSTRY_L2}'], ['Date', TARGET_DATE], ['Period', '日榜']]:
+        ws.append(row)
+    ws.append([])
+    for rt2 in RT: ws.append([rt2, len(all_data.get(rt2, []))])
+    ws.append(['Total', total])
+    for rt2 in RT:
+        items = all_data.get(rt2, [])
+        if items:
+            ws2 = wb.create_sheet(rt2)
+            priority = ['ranking_type', 'global_rank', 'page_number', 'page_rank',
+                        'title', 'author', 'douyin_id', 'publish_date', 'cover_url', 'video_url']
+            other_keys = [k for k in items[0].keys() if k not in priority and not k.endswith('_numeric')]
+            keys = priority + other_keys
+            ws2.append(keys)
+            for item in items:
+                ws2.append([item.get(k, '') for k in keys])
+    xlsx_path = OUT_DIR / f'{prefix}.xlsx'
+    wb.save(str(xlsx_path))
+
+    # Meta
+    all_ranks = {}
+    for rt2 in RT:
+        ranks = sorted([i['global_rank'] for i in all_data.get(rt2, [])])
+        all_ranks[rt2] = {'ranks': ranks, 'missing': [r for r in range(1, 21) if r not in ranks]}
+
+    video_url_all_empty = all(not item.get('video_url') for rt2 in RT for item in all_data.get(rt2, []))
+
+    meta = {
+        'task_id': TASK_ID, 'profile_id': ALIAS, 'collected_at': collected_at,
+        'industry_level_1': INDUSTRY_L1, 'industry_level_2': INDUSTRY_L2,
+        'industry_display': f'{INDUSTRY_L1}/{INDUSTRY_L2}',
+        'lead_count': lead, 'traffic_count': traffic, 'popular_count': popular,
+        'total_count': total,
+        'rank_continuity': all(len(v['missing']) == 0 for v in all_ranks.values()),
+        'missing_ranks': {k: v['missing'] for k, v in all_ranks.items()},
+        'missing_fields': missing_fields,
+        'missing_field_counts': mf_counts,
+        'completeness': 'PARTIAL' if video_url_all_empty else 'COMPLETE',
+        'industry_verified': True,
+        'page2_dom_verified': page2_verified,
+        'video_url_note': '页面未提供视频级链接' if video_url_all_empty else '',
+        'qa': {
+            'douyin_id_suffix_error_count': douyin_id_suffix_errors,
+            'title_equals_author_count': title_equals_author,
+            'empty_author_count': empty_author,
+            'empty_douyin_id_count': empty_douyin
+        }
+    }
+    meta_path = OUT_DIR / f'{prefix}.meta.json'
+    meta_path.write_text(json.dumps(meta, indent=2, ensure_ascii=False))
+
+    print(f'SAVED|{OUT_DIR}', flush=True)
+    print(f'SUMMARY|lead={lead}|traffic={traffic}|popular={popular}|total={total}', flush=True)
+    print(f'COMPLETENESS|{meta["completeness"]}', flush=True)
+
+    ctx.close()
+    LOCK_FILE.unlink(missing_ok=True)
+    print('DONE', flush=True)
+
+if __name__ == '__main__':
+    main()