sino-bc-cli 1.0.0-beta.0

package/dist/skills/biz-line-strategy-generate/scripts/test_pipeline.py

@@ -0,0 +1,253 @@
+"""使用真实单条工作流验证拉数/AI滑动交接，不请求生产接口。"""
+import json
+from pathlib import Path
+import sys
+import tempfile
+import threading
+import unittest
+from concurrent.futures import ThreadPoolExecutor
+from unittest.mock import patch
+
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from run_workflow import run_batch
+from strategy_output import submit_tag_choices
+from test_workflow import arguments, small_payload
+from test_ai_strategy import AI_TEXT
+
+
+class SlidingPipeline(unittest.TestCase):
+    """用事件控制先后，不靠耗时猜测滑动补位是否发生。"""
+
+    def execute(self, root, targets, fetch, progress, cancel=None, concurrency=3):
+        """仅替代业务拉数与固定分析，标签、AI文件协议、Excel和清理走真实实现。"""
+        args = arguments(root / 'output', targets)
+        args.concurrency = concurrency
+        dictionaries = {key: [{'id': 11, 'name': '其他', 'isOther': 1}]
+                        for key in ('budget', 'product', 'audience')}
+        def analyze(directory):
+            payload = small_payload()
+            (directory / 'payload.json').write_text(json.dumps(payload), encoding='utf-8')
+            return payload, {'detail_count': 1, 'curr_total': 100}
+        with patch('run_workflow.fetch_business', side_effect=fetch), \
+             patch('run_workflow.summarize_request', side_effect=analyze), \
+             patch('strategy_output.TagCache.get', return_value=dictionaries):
+            return run_batch(args, progress=progress, cancel=cancel, temp_parent=root)
+
+    def reply(self, event):
+        """只模拟AI决策，提交/身份校验及工作簿消费沿用生产入口。"""
+        if event.get('event') not in ('tag_review_required', 'ai_strategy_required'):
+            return
+        packet = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+        if event['event'] == 'tag_review_required':
+            choices = {'selections': {key: [{'choiceKey': item['labels'][0]['choiceKey'], 'reason': '样本无适合具体标签'}]
+                                      for key, item in packet['strategies'].items()}}
+            submit_tag_choices(event['request_path'], event['reviewId'], choices)
+        else:
+            reply = {key: packet[key] for key in ('bizLineId', 'attempt', 'requestId')}
+            Path(event['response_path']).write_text(json.dumps({**reply, 'text': AI_TEXT}), encoding='utf-8')
+
+    def biz(self, ident):
+        """真实上下文由当前目标生成，不从上一个业务线继承。"""
+        return {'id': ident, 'name': f'样本{ident}', 'adCategoryIndustryIds': [11]}
+
+    def test_one_line_enters_ai_refills_fetch_before_other_two_finish(self):
+        """第一条开始审核时第四条已拉数，第二/三条仍被刻意阻塞。"""
+        first_three = threading.Barrier(3)
+        slow_fetches = threading.Event()
+        next_fetch = threading.Event()
+        release_ai = threading.Event()
+        seen = []
+        lock = threading.Lock()
+        def fetch(args):
+            with lock:
+                seen.append(args.id)
+            if args.id <= 3:
+                first_three.wait(timeout=5)
+            if args.id in (2, 3):
+                if not slow_fetches.wait(5):
+                    raise RuntimeError('等待控制放行拉数超时')
+            if args.id == 4:
+                next_fetch.set()
+            return self.biz(args.id)
+        def progress(event):
+            if event.get('event') == 'ai_strategy_required' and event['id'] == 1:
+                if not release_ai.wait(5):
+                    raise RuntimeError('等待控制放行AI超时')
+            self.reply(event)
+        with tempfile.TemporaryDirectory() as tmp, ThreadPoolExecutor(max_workers=1) as executor:
+            root = Path(tmp)
+            future = executor.submit(self.execute, root, [1, 2, 3, 4], fetch, progress)
+            try:
+                self.assertTrue(next_fetch.wait(3), '第一条转入AI后没有逐条补拉第四条')
+                self.assertFalse(slow_fetches.is_set())
+                self.assertFalse(release_ai.is_set())
+                with lock:
+                    self.assertEqual(set(seen), {1, 2, 3, 4})
+            finally:
+                slow_fetches.set()
+                release_ai.set()
+            result = future.result(timeout=10)
+            self.assertTrue(result['ok'], result)
+            self.assertFalse(list(root.rglob('batch-*')))
+
+    def test_stage_caps_and_global_six_bound_queue_before_tag_request(self):
+        """AI三条全部占用时，只预取另三条；等待者尚未生成审核请求。"""
+        self.check_capacity(3)
+
+    def test_smaller_concurrency_limits_both_stages_and_total(self):
+        """参数1/2同样滑动，分别限制总在途2/4，不沿用固定六条。"""
+        for capacity in (1, 2):
+            with self.subTest(capacity=capacity):
+                self.check_capacity(capacity)
+
+    def check_capacity(self, capacity):
+        """通过真实请求文件及拉数/AI阻塞观察阶段上限，不检查内部计数实现。"""
+        lock = threading.Lock()
+        first_fetches = threading.Barrier(capacity)
+        ready = threading.Event()
+        release_ai = threading.Event()
+        ai_started, waiting, fetched, tagged = set(), set(), set(), set()
+        fetch_active = fetch_peak = ai_active = ai_peak = 0
+        def fetch(args):
+            nonlocal fetch_active, fetch_peak
+            with lock:
+                fetched.add(args.id)
+                fetch_active += 1
+                fetch_peak = max(fetch_peak, fetch_active)
+            if args.id <= capacity:
+                first_fetches.wait(timeout=5)
+            with lock:
+                fetch_active -= 1
+            return self.biz(args.id)
+        def progress(event):
+            nonlocal ai_active, ai_peak
+            with lock:
+                if event.get('stage') == 'wait_ai_slot':
+                    waiting.add(event['id'])
+                if event.get('event') == 'tag_review_required':
+                    tagged.add(event['id'])
+                if event.get('event') == 'ai_strategy_required':
+                    ai_started.add(event['id'])
+                    ai_active += 1
+                    ai_peak = max(ai_peak, ai_active)
+                if len(ai_started) >= capacity and len(waiting) >= capacity * 2:
+                    ready.set()
+            if event.get('event') == 'ai_strategy_required':
+                if not release_ai.wait(5):
+                    raise RuntimeError('等待控制放行AI超时')
+                with lock:
+                    ai_active -= 1
+            self.reply(event)
+        with tempfile.TemporaryDirectory() as tmp, ThreadPoolExecutor(max_workers=1) as executor:
+            root = Path(tmp)
+            future = executor.submit(self.execute, root, list(range(1, 11)), fetch, progress,
+                                     concurrency=capacity)
+            try:
+                self.assertTrue(ready.wait(3), '没有形成3条AI＋3条已预取等待')
+                with lock:
+                    self.assertEqual(len(fetched), capacity * 2)
+                    self.assertEqual(len(tagged), capacity)
+                    self.assertEqual((fetch_peak, ai_peak), (capacity, capacity))
+                self.assertEqual(len(list(root.rglob('line-*'))), capacity * 2)
+                self.assertEqual(len(list(root.rglob('tag-review.1.request.json'))), capacity)
+            finally:
+                release_ai.set()
+            result = future.result(timeout=15)
+            self.assertTrue(result['ok'], result)
+            self.assertEqual(result['success'], 10)
+            self.assertLessEqual(fetch_peak, capacity)
+            self.assertLessEqual(ai_peak, capacity)
+            self.assertTrue(all('wait_ai_slot' in row['timings'] for row in result['results']))
+            self.assertFalse(list(root.rglob('batch-*')))
+
+    def test_fetch_retry_and_ai_exhaustion_release_slots_without_crossing_rounds(self):
+        """拉数技术失败只在首轮结束后重试，AI三次失败不重拉，后续条目继续。"""
+        counts, completed, ai_attempts = {}, set(), []
+        lock = threading.Lock()
+        def fetch(args):
+            with lock:
+                counts[args.id] = counts.get(args.id, 0) + 1
+                if args.attempt > 1:
+                    self.assertEqual(completed, {1, 2, 3, 4})
+            if args.id == 2 and args.attempt == 1:
+                raise OSError('本条首次拉数失败')
+            return self.biz(args.id)
+        def progress(event):
+            if event.get('event') == 'completed' and event['attempt'] == 1:
+                with lock:
+                    completed.add(event['id'])
+            if event.get('event') == 'ai_strategy_required' and event['id'] == 1:
+                ai_attempts.append(event['reviewAttempt'])
+                packet = json.loads(Path(event['request_path']).read_text(encoding='utf-8'))
+                reply = {key: packet[key] for key in ('bizLineId', 'attempt', 'requestId')}
+                Path(event['response_path']).write_text(json.dumps({**reply, 'text': '缺少四段标题'}), encoding='utf-8')
+            else:
+                self.reply(event)
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            result = self.execute(root, [1, 2, 3, 4], fetch, progress, concurrency=1)
+            self.assertEqual(counts, {1: 1, 2: 2, 3: 1, 4: 1})
+            self.assertEqual(ai_attempts, [1, 2, 3])
+            self.assertEqual(result['success'], 3)
+            self.assertEqual([row['attempts'] for row in result['results']], [1, 2, 1, 1])
+            self.assertTrue(result['results'][0]['ai_strategy_exhausted'])
+            self.assertFalse(list(root.rglob('batch-*')))
+
+    def test_cancel_while_waiting_for_ai_does_not_issue_request_or_leak(self):
+        """concurrency=1为一拉一AI，第二条排队取消后不能发审核或启动第三条。"""
+        cancel = threading.Event()
+        queued = threading.Event()
+        ai_started = threading.Event()
+        fetched, tagged = [], []
+        def fetch(args):
+            fetched.append(args.id)
+            return self.biz(args.id)
+        def progress(event):
+            if event.get('stage') == 'wait_ai_slot' and event['id'] == 2:
+                queued.set()
+            if event.get('event') == 'tag_review_required':
+                tagged.append(event['id'])
+            if event.get('event') == 'ai_strategy_required':
+                ai_started.set()
+                cancel.wait(5)
+                return
+            self.reply(event)
+        with tempfile.TemporaryDirectory() as tmp, ThreadPoolExecutor(max_workers=1) as executor:
+            root = Path(tmp)
+            future = executor.submit(self.execute, root, [1, 2, 3], fetch, progress, cancel, 1)
+            try:
+                self.assertTrue(ai_started.wait(3))
+                self.assertTrue(queued.wait(3), '第二条没有在第一条AI期间完成预取')
+            finally:
+                cancel.set()
+            result = future.result(timeout=10)
+            self.assertFalse(result['ok'])
+            self.assertEqual(fetched, [1, 2])
+            self.assertEqual(tagged, [1])
+            self.assertEqual([row['attempts'] for row in result['results']], [1, 1, 0])
+            self.assertTrue(result['cleanup']['ok'])
+            self.assertFalse(list(root.rglob('batch-*')))
+
+    def test_outer_worker_exception_releases_reserved_fetch_slot(self):
+        """原单条try之外抛错也不能占住唯一拉数名额或被盲目重放。"""
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            args = arguments(root / 'output', [1, 2, 3])
+            args.concurrency = 1
+            seen = []
+            def worker(target, args, batch, cancel, progress):
+                seen.append(target)
+                if target == 1:
+                    raise OSError('worker外层错误')
+                return {'id': target, 'ok': True}
+            result = run_batch(args, worker=worker, temp_parent=root, progress=lambda _: None)
+            self.assertEqual(seen, [1, 2, 3])
+            self.assertEqual(result['success'], 2)
+            self.assertEqual(result['results'][0]['failed_stage'], 'worker')
+            self.assertEqual(result['results'][0]['attempts'], 1)
+            self.assertTrue(result['cleanup']['ok'])
+
+
+if __name__ == '__main__':
+    unittest.main()

package/dist/skills/biz-line-strategy-generate/scripts/test_strategy_rules.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""不发网：会议口径 + 实跑踩坑（直写文件、出价统计、环比结论、双 sheet）。"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+SCRIPTS = Path(__file__).resolve().parent
+if str(SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS))
+
+from cli_json import (  # noqa: E402
+    bid_adjust_stats,
+    budget_abs_share,
+    exec_cli_to_file,
+    is_first_period,
+    is_ghost_enum,
+    list_query_body,
+    naming_patterns,
+    period_verdict,
+    region_bucket,
+    summarize_countries,
+)
+from fetch_data import PAGE_CAP  # noqa: E402
+
+
+def test_list_query_uses_data_body_not_flags():
+    named = list_query_body(name="华南-S级-rednote小红书")
+    assert named["name"] == "华南-S级-rednote小红书"
+    assert named["sortType"] == "PERIOD"
+    assert "idList" not in named
+    by_id = list_query_body(biz_id=1164)
+    assert by_id["idList"] == [1164]
+
+
+def test_exec_cli_to_file_keeps_payload_over_64kb():
+    with tempfile.TemporaryDirectory() as tmp:
+        out = Path(tmp) / "big.out.json"
+        # 在子进程内构造大回包，避免 Windows argv 长度上限干扰本测试。
+        script = 'import json; print(json.dumps({"ok": True, "pad": "x" * 80000}))'
+        rc, raw = exec_cli_to_file([sys.executable, "-c", script], out)
+        assert rc == 0
+        assert out.stat().st_size > 65536
+        parsed = json.loads(raw)
+        assert parsed["ok"] is True
+        assert len(parsed["pad"]) == 80000
+
+
+def test_page_cap_covers_tiktok_bid_pages():
+    # 大业务线广告数据超过 10 万行，80 页上限会截断。
+    assert PAGE_CAP >= 200
+
+
+def test_period_verdict_follows_qoq_not_kpi():
+    # 有上期时仅以 2% 改善判断，与是否达到阈值无关。
+    from cli_json import learning_text, amount_change
+    from strategy_output import effect_code
+    cases = [(hit, trend, '有效' if trend == '变好' else '无效',
+              '策略有效' if trend == '变好' else '需关停', 1 if trend == '变好' else 2)
+             for hit in (True, False) for trend in ('变好', '稳定', '变差')]
+    for hit, trend, verdict, note, effect in cases:
+        actual = period_verdict(first_period=False, qoq_label=trend, kpi_usable=True, kpi_hit=hit)
+        assert actual == verdict
+        assert learning_text(actual) == f'结论：{verdict}\n说明：{note}'
+        assert effect_code(actual) == effect
+    for hit in (None, True, False):
+        assert period_verdict(first_period=False, qoq_label='无法对比', kpi_usable=True, kpi_hit=hit) == '待观察'
+    assert period_verdict(first_period=False, qoq_label='变好', kpi_usable=False) == '待观察'
+    assert amount_change(150, 100) == '环比 +50.00%'
+    assert '不可计算' in amount_change(100, 0)
+
+
+def test_is_first_period_uses_prev_dates():
+    assert is_first_period({}) is True
+    assert is_first_period({"prevPeriodStart": "2026-09-07", "prevPeriodEnd": "2026-09-13"}) is False
+
+
+def test_ghost_enum_zero_share_is_not_stop():
+    assert is_ghost_enum(0.0, 0.0) is True
+    assert is_ghost_enum(6.0, 0.0) is False
+
+
+def test_region_bucket_non_sea_before_sea():
+    assert region_bucket("两性-恋爱攻略-全球非东南亚-自制-英语-install") == "other"
+    assert region_bucket("KPOP测试-舞蹈二创-东南亚仅马泰") == "sea"
+
+
+def test_bid_adjust_stats_aggregates_and_lists_when_few():
+    items = [
+        {"name": "A", "from": 5.0, "to": 8.0, "times": 2},
+        {"name": "B", "from": 10.0, "to": 7.0, "times": 1},
+        {"name": "C", "from": 3.0, "to": 3.0, "times": 1},
+    ]
+    stats = bid_adjust_stats(items)
+    assert stats["raise_n"] == 1
+    assert stats["lower_n"] == 1
+    assert stats["flat_n"] == 1
+    assert stats["median_abs"] == 3.0
+    assert stats["list_all"] is True
+    assert len(stats["details"]) == 3
+    many = [{"name": str(i), "from": 1.0, "to": 2.0, "times": 1} for i in range(12)]
+    crowded = bid_adjust_stats(many)
+    assert crowded["raise_n"] == 12
+    assert crowded["list_all"] is False
+    assert crowded["details"] == []
+
+
+def test_budget_abs_share_flags_contradiction():
+    line = budget_abs_share("FB", prev_abs=28886, curr_abs=25194, prev_share=8.8, curr_share=11.6)
+    assert "$28,886 → $25,194" in line
+    assert "8.8% → 11.6%" in line
+    assert "占比升但金额降" in line
+
+
+def test_naming_patterns_picks_short_tokens():
+    names = [
+        "KPOP测试-舞蹈二创-802-东南亚仅越南-自制-英语-激活-2609",
+        "KPOP测试-线下周边-803-东南亚仅马泰-自制-英语-登录-2609",
+        "彩妆测试-整体妆容-东南亚-自制-英语-install-260916",
+    ]
+    text = naming_patterns(names, limit=10)
+    assert "KPOP" in text or "舞蹈" in text
+    assert "彩妆" in text or "整体妆容" in text
+    assert len(text) < 200
+
+
+def test_summarize_countries_aggregates_when_over_50():
+    countries = [f"国{i}" for i in range(60)]
+    main, extra = summarize_countries(countries)
+    assert "超过 50" in main or "区域" in main or "大洲" in main
+    assert len(extra) == 60
+
+
+def test_build_report_writes_strategy_and_detail_sheets():
+    from build_report import write_xlsx
+
+    with tempfile.TemporaryDirectory() as tmp:
+        out = os.path.join(tmp, "out.xlsx")
+        rows = [
+            {
+                "group": "APP-华南组",
+                "bizLine": "示例",
+                "period": "本期：2026-09-14～2026-09-20\n上期：2026-09-07～2026-09-13",
+                "project": "项目A",
+                "budgetStrategy": "【预算】",
+                "budgetLearning": "结论：有效",
+                "productStrategy": "【广告目标】",
+                "productLearning": "结论：待观察",
+                "audienceStrategy": "【国家】",
+                "audienceLearning": "结论：有效",
+                "creativeStrategy": "【广告】",
+                "creativeLearning": "结论：有效",
+            }
+        ]
+        details = [
+            {
+                "bizLine": "示例",
+                "kind": "国家",
+                "action": "新增",
+                "channel": "TikTok",
+                "name": "西撒哈拉",
+                "extra": "消耗 $0",
+            }
+        ]
+        write_xlsx(rows, out, details=details)
+        with zipfile.ZipFile(out) as zf:
+            names = zf.namelist()
+            assert "xl/worksheets/sheet1.xml" in names
+            assert "xl/worksheets/sheet2.xml" in names
+            wb = zf.read("xl/workbook.xml").decode("utf-8")
+            assert "策略" in wb
+            assert "明细" in wb
+            sheet2 = zf.read("xl/worksheets/sheet2.xml").decode("utf-8")
+            sst = zf.read("xl/sharedStrings.xml").decode("utf-8")
+            assert "西撒哈拉" in sst
+            assert "sheetData" in sheet2
+
+
+def test_build_report_preserves_carriage_returns():
+    """客户 KPI 与广告名中的 CR/CRLF 必须逐字保留，不能被 XML 换行归一化。"""
+    from build_report import write_xlsx, validate_xlsx
+
+    text = "客户 KPI\r\n第二行\r第三行\n<&> &amp; &#13;"
+    rows = [{"bizLine": "换行验证", "budgetLearning": text}]
+    details = [{"bizLine": "换行验证", "name": text, "extra": text * 100}]
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "line-endings.xlsx"
+        write_xlsx(rows, str(path), details)
+        assert validate_xlsx(path, rows, details)["rows"] == 1
+
+
+if __name__ == "__main__":
+    tests = [
+        test_list_query_uses_data_body_not_flags,
+        test_exec_cli_to_file_keeps_payload_over_64kb,
+        test_page_cap_covers_tiktok_bid_pages,
+        test_period_verdict_follows_qoq_not_kpi,
+        test_is_first_period_uses_prev_dates,
+        test_ghost_enum_zero_share_is_not_stop,
+        test_region_bucket_non_sea_before_sea,
+        test_bid_adjust_stats_aggregates_and_lists_when_few,
+        test_budget_abs_share_flags_contradiction,
+        test_naming_patterns_picks_short_tokens,
+        test_summarize_countries_aggregates_when_over_50,
+        test_build_report_writes_strategy_and_detail_sheets,
+        test_build_report_preserves_carriage_returns,
+    ]
+    failed = 0
+    for fn in tests:
+        try:
+            fn()
+            print("ok", fn.__name__)
+        except Exception as e:
+            failed += 1
+            print("FAIL", fn.__name__, type(e).__name__, e)
+    if failed:
+        raise SystemExit(1)
+    print("DONE")