sino-bc-cli 1.8.20 → 1.8.21

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

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""业务线策略唯一生成入口：最多三个并发，逐条校验、交付和清理。"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import signal
+import sys
+import tempfile
+import threading
+import time
+from argparse import Namespace
+from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
+from pathlib import Path
+
+# 从任意 cwd 或安装目录启动均定位到技能自身；不在源码树生成缓存。
+sys.dont_write_bytecode = True
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from build_report import default_output_path, validate_xlsx, write_xlsx
+from cleanup import OwnedDirectory, MARKER
+from cli_json import cli_context
+from fetch_data import argument_parser, fetch_business
+from summarize import summarize_request
+
+_output_lock = threading.Lock()
+
+
+class PublishError(RuntimeError):
+    """发布失败且无法移除本次不完整目标时，保留精确残留路径。"""
+    def __init__(self, message, path):
+        super().__init__(message)
+        self.residual_path = str(path)
+
+
+def emit(event):
+    """并发进度输出按 JSON 行加锁，结果无需额外磁盘日志。"""
+    with _output_lock:
+        print(json.dumps(event, ensure_ascii=False), flush=True)
+
+
+def publish(temp, final, payload):
+    """先校验临时文件，再独占创建目标；任何中途错误仅清理自己创建的目标。"""
+    validate_xlsx(temp, payload['rows'], payload['details'])
+    created = False
+    try:
+        with final.open('xb') as output:
+            created = True
+            with temp.open('rb') as source:
+                shutil.copyfileobj(source, output)
+        validate_xlsx(final, payload['rows'], payload['details'])
+    except BaseException as original:
+        if created:
+            try:
+                final.unlink()
+            except OSError as cleanup_error:
+                raise PublishError(f'发布失败：{original}；删除不完整目标失败：{cleanup_error}', final) from original
+        raise
+
+
+def execute_business(target, args, batch, cancel, progress=emit):
+    """每个名额覆盖完整生命周期，清理结束后才返回调度器。"""
+    owned = OwnedDirectory.create(batch.path, f'line-{target or "named"}-')
+    result = {'id': target, 'ok': False, 'timings': {}, 'output_path': None}
+    current_stage = 'fetch'
+    started = time.perf_counter()
+    final = None
+
+    def stage(name, function):
+        nonlocal current_stage
+        current_stage = name
+        if cancel.is_set():
+            raise InterruptedError('任务已取消')
+        begin = time.perf_counter()
+        progress({'id': result['id'], 'stage': name, 'status': 'running'})
+        try:
+            return function()
+        finally:
+            result['timings'][name] = round(time.perf_counter() - begin, 3)
+
+    try:
+        # 最终目录必须在整个批次临时树之外，而非仅在当前业务线之外。
+        output_dir = Path(args.output_dir).resolve()
+        if output_dir.is_relative_to(batch.path):
+            raise ValueError('最终 Excel 目录不能位于批次临时目录内')
+        local_args = Namespace(**{**vars(args), 'id': target or 0, 'request_dir': str(owned.path)})
+        with cli_context(cancel, lambda text: progress({'id': result['id'], 'stage': 'fetch', 'detail': text})):
+            biz = stage('fetch', lambda: fetch_business(local_args))
+        result['id'], result['name'] = int(biz['id']), str(biz.get('name') or '')
+        payload, summary = stage('analyze', lambda: summarize_request(owned.path))
+        result['detail_count'] = summary['detail_count']
+        safe_name = re.sub(r'[<>:"/\\|?*\x00-\x1f]', '_', result['name'])[:55].rstrip(' .') or '业务线'
+        final = output_dir / f'业务线策略_{result["id"]}_{safe_name}_{owned.token[:12]}.xlsx'
+        output_dir.mkdir(parents=True, exist_ok=True)
+        temp = owned.path / 'final.xlsx'
+        stage('export', lambda: write_xlsx(payload['rows'], str(temp), payload['details']))
+        stage('validate_publish', lambda: publish(temp, final, payload))
+        result['output_path'] = str(final)
+        result['ok'] = True
+    except Exception as exc:
+        result.update(error=str(exc), failed_stage=current_stage)
+        if isinstance(exc, PublishError):
+            result['residual_output'] = exc.residual_path
+    finally:
+        begin = time.perf_counter()
+        cleanup = owned.cleanup(final)
+        result['timings']['cleanup'] = round(time.perf_counter() - begin, 3)
+        result['cleanup'] = cleanup
+        if not cleanup['ok']:
+            result.update(ok=False, cleanup_failed=True)
+        result['timings']['total'] = round(time.perf_counter() - started, 3)
+    return result
+
+
+def run_batch(args, *, cancel=None, worker=execute_business, progress=emit, temp_parent=None):
+    """只提交可立即运行的三个任务；已完成任务交付后继续补位。"""
+    if args.concurrency not in (1, 2, 3):
+        raise ValueError('并发只能设置为 1、2 或 3')
+    if any(i <= 0 for i in args.id):
+        raise ValueError('业务线 ID 必须为正整数')
+    for prefix in ('curr', 'prev'):
+        if bool(getattr(args, f'{prefix}_start')) != bool(getattr(args, f'{prefix}_end')):
+            raise ValueError('用户指定的起止日期必须成对提供')
+    targets = list(dict.fromkeys(args.id)) if args.id else [None]
+    cancel = cancel or threading.Event()
+    batch = OwnedDirectory.create(Path(temp_parent or tempfile.gettempdir()) / 'sino-bc-strategy', 'batch-')
+    results, pending = [], {}
+    remaining = iter(targets)
+    started = time.perf_counter()
+    try:
+        with ThreadPoolExecutor(max_workers=args.concurrency) as pool:
+            while True:
+                while not cancel.is_set() and len(pending) < args.concurrency:
+                    try:
+                        target = next(remaining)
+                    except StopIteration:
+                        break
+                    pending[pool.submit(worker, target, args, batch, cancel, progress)] = target
+                if not pending:
+                    break
+                finished, _ = wait(pending, timeout=0.2, return_when=FIRST_COMPLETED)
+                for future in finished:
+                    target = pending.pop(future)
+                    try:
+                        result = future.result()
+                    except Exception as exc:
+                        result = {'id': target, 'ok': False, 'error': str(exc), 'failed_stage': 'worker'}
+                    results.append(result)
+                    progress({'event': 'completed', **result})
+            # 未启动任务也要明确返回取消状态，不能从批次结果中消失。
+            for target in remaining:
+                results.append({'id': target, 'ok': False, 'failed_stage': 'cancelled', 'error': '任务未启动，已取消'})
+    finally:
+        # 已失败的清理目录保留并报告，不由父级递归重试掩盖错误。
+        batch.validate()
+        children = [p for p in batch.path.iterdir() if p.name != MARKER]
+        cleanup = ({'ok': False, 'residual': [{'path': str(p), 'error': '业务线目录尚有残留'} for p in children]} if children else batch.cleanup())
+    success = sum(r['ok'] for r in results)
+    return {'ok': success == len(targets) and cleanup['ok'] and not cancel.is_set(), 'success': success,
+            'failed': len(results) - success, 'results': results, 'cleanup': cleanup,
+            'elapsed_seconds': round(time.perf_counter() - started, 3)}
+
+
+def main():
+    parser = argument_parser(batch=True)
+    parser.description = __doc__
+    parser.add_argument('--concurrency', type=int, choices=(1, 2, 3), default=3)
+    parser.add_argument('--output-dir', default=str(Path(default_output_path()).parent))
+    args = parser.parse_args()
+    cancel = threading.Event()
+    # 可处理的 Ctrl+C/SIGTERM 只发信号，worker 关闭自己的 CLI 后清理。
+    previous = {sig: signal.signal(sig, lambda *_: cancel.set()) for sig in (signal.SIGINT, signal.SIGTERM)}
+    try:
+        result = run_batch(args, cancel=cancel)
+        emit({'event': 'batch_completed', **result})
+        return 0 if result['ok'] else 1
+    except ValueError as exc:
+        emit({'ok': False, 'error': str(exc)})
+        return 2
+    finally:
+        for sig, handler in previous.items():
+            signal.signal(sig, handler)
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())