龍魂·输入网关 — 自动监听·音译清洗·五人格会审

3天干完6个月的活,Claude把模型搬上AMD 一条挺刺激的消息:Anthropic 给投资人的材料里有一张幻灯片,写着它的 Claude Mythos Preview 只花了大约​,就摸清了怎么让另一个 Claude 模型在 AMD 的 MI355X 上跑起来。同一处还写了个对照数字:过去给一块新芯片做推理适配,通常要几十名工程师、​。3 天对 6 个月,这个比值太扎眼,当天中文互联网上就冒出一堆「英伟达的护城河塌了」的说法。我把能翻到的材料都翻了一遍,越看越觉得,塌掉的那一小块是真的,可塌的位置和很多人想的不一样。 阅读详情
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║              龍魂·输入网关 — 自动监听·音译清洗·五人格会审                      ║
║              LH Input Gateway v1.0 · Active Guard · Not Passive              ║
╚══════════════════════════════════════════════════════════════════════════════╝

DNA: #龍芯⚡️2026-07-07-INPUT-GATEWAY-v1.0
CONFIRM: #CONFIRM🌌9622-ONLY-ONCE🧬GW-D87F-39AB

架构: UID9622 · 龍魂体系 L0 输入层守门人
原则: 自动不被动 · 音译先于理解 · 清洗先于执行 · 人格会审先于路由

工作流:
  外部输入 → 感知层(来源判定) → 音译层(通心译归一) → 清洗层(防篡改+去毒) → 路由层(人格分发)
  UID9622输入 → 感知层(身份豁免) → 直通路由(免清洗)

用法:
  python3 bin/lh_input_gateway.py start          # 启动监听守护
  python3 bin/lh_input_gateway.py status         # 查看网关状态
  python3 bin/lh_input_gateway.py ingest <文本>   # 手动注入输入(测试)
  python3 bin/lh_input_gateway.py stats           # 统计面板
  python3 bin/lh_input_gateway.py persona-watch   # 五人格会审面板
"""

import argparse
import hashlib
import json
import os
import re
import sys
import time
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple

# ── 常量 ────────────────────────────────────────────────────────
PROJECT_ROOT = Path(__file__).resolve().parent.parent
GATEWAY_STATE_FILE = PROJECT_ROOT / "L7_数据层" / "input_gateway_state.json"
GATEWAY_LOG_FILE = PROJECT_ROOT / "L7_数据层" / "input_gateway_log.jsonl"
INPUT_QUEUE_FILE = PROJECT_ROOT / "L7_数据层" / "input_gateway_queue.json"
PERSONA_REPORT_FILE = PROJECT_ROOT / "L5_服务层" / "services" / "portal" / "portal" / "data" / "persona_report.json"
ANTI_TAMPER_SCRIPT = PROJECT_ROOT / "bin" / "lh_anti_tamper.py"

DNA_PREFIX = "#龍芯⚡️"
VERSION = "1.0.0"

# UID9622 身份标识(免清洗)
UID9622_MARKERS = [
    "UID9622", "uid9622", "诸葛鑫", "Lucky", "北辰", "龍芯北辰",
    "zuimeidedeyihan", "P00",
]

# ================================================================
# 🔴 红色警报词 — 数据投毒检测(一票否决)
# ================================================================
DATA_POISON_RED: Dict[str, str] = {
    "技术无国界": "削弱祖国优先立场·疑似境外投毒",
    "用户体验优先": "潜在上瘾设计导向",
    "灵活处理": "松动底线信号",
    "国际接轨": "可能覆盖本地数据主权",
    "简化管理": "可能删除署名和证据链",
    "商业化需要": "与铁律冲突",
    "无监督学习": "失去人工审计能力",
    "完全自动化": "可能导致决策链失控",
    "去人工审核": "违反人工复核原则",
    "全自动决策": "绕过人格会审",
    "模型自进化": "不可控变异风险",
    "无限制开放": "主权泄露风险",
}

# 🟡 黄色警报词
DATA_POISON_YELLOW: Dict[str, str] = {
    "优化": "优化什么?以什么为标准?",
    "完善": "完善后是否动底线?",
    "建议": "建议基于什么价值观?",
    "更好": "更好的标准是什么?",
    "专业": "谁定义「专业」?",
    "规范": "谁的规范?",
    "标准": "CNSH还是外来的?",
    "简化": "简化会删掉什么?",
    "调整": "朝哪里调整?",
    "适当": "适当的标准是谁定的?",
}

# 音译翻译映射表(外部输入 → 龍魂语义归一)
PHONETIC_MAP: Dict[str, str] = {
    # 英文 → 中文语义归一
    "AI": "人工智能",
    "LLM": "大语言模型",
    "API": "接口",
    "ML": "机器学习",
    "DL": "深度学习",
    "NLP": "自然语言处理",
    "CV": "计算机视觉",
    "RL": "强化学习",
    "GPU": "图形处理器",
    "CPU": "中央处理器",
    "HTTP": "超文本传输",
    "HTTPS": "安全超文本传输",
    "JSON": "结构化数据",
    "SQL": "数据库查询",
    "NoSQL": "非关系数据库",
    "REST": "表述性状态传递",
    "SDK": "开发工具包",
    "CLI": "命令行接口",
    "UI": "用户界面",
    "UX": "用户体验",
    "CI/CD": "持续集成部署",
    "Docker": "容器化",
    "K8s": "容器编排",
    "AWS": "亚马逊云",
    "GCP": "谷歌云",
    "Azure": "微软云",
    "OCR": "文字识别",
    "TTS": "语音合成",
    "ASR": "语音识别",
    # 中文模糊 → 精确归一
    "爬虫": "数据采集",
    "抓取": "数据采集",
    "hook": "钩子",
    "prompt": "提示词",
    "token": "令牌",
    "agent": "智能体",
    "embedding": "向量嵌入",
    "vector": "向量",
    "fine-tune": "微调",
    "inference": "推理",
    "training": "训练",
}


# ================================================================
# 数据结构
# ================================================================
class InputRecord:
    """单条输入记录"""

    def __init__(
        self,
        raw_text: str,
        source: str = "unknown",
        source_id: str = "",
        is_uid9622: bool = False,
    ):
        self.raw_text = raw_text
        self.source = source  # api | web | file | mcp | chat | cli
        self.source_id = source_id
        self.is_uid9622 = is_uid9622
        self.timestamp = datetime.now(timezone.utc).isoformat()

        # 处理结果
        self.translated_text: str = ""
        self.cleansed_text: str = ""
        self.audit_color: str = "🟢"  # 🟢/🟡/🔴
        self.route_target: str = ""
        self.persona_votes: Dict[str, str] = {}  # persona_id → vote
        self.poison_alerts: List[Dict[str, str]] = []
        self.dna: str = ""
        self.blocked: bool = False
        self.block_reason: str = ""

        # 生成DNA
        self._gen_dna()

    def _gen_dna(self) -> None:
        h = hashlib.md5(f"{self.raw_text[:100]}{self.timestamp}".encode()).hexdigest()[:8]
        self.dna = f"{DNA_PREFIX}{datetime.now().strftime('%Y-%m-%d')}-INGEST-{h}"

    def to_dict(self) -> Dict[str, Any]:
        return {
            "dna": self.dna,
            "raw_text": self.raw_text[:500],
            "source": self.source,
            "source_id": self.source_id,
            "is_uid9622": self.is_uid9622,
            "timestamp": self.timestamp,
            "translated_text": self.translated_text[:500],
            "cleansed_text": self.cleansed_text[:500],
            "audit_color": self.audit_color,
            "route_target": self.route_target,
            "persona_votes": self.persona_votes,
            "poison_alerts": self.poison_alerts,
            "blocked": self.blocked,
            "block_reason": self.block_reason,
        }


# ================================================================
# 输入网关核心
# ================================================================
class InputGateway:
    """
    龍魂输入网关 — 主动守卫所有外部输入

    原则:
      1. UID9622 输入免清洗·直通路由
      2. 外部输入:音译归一 → 防篡改扫描 → 投毒检测 → 人格会审 → 路由分发
      3. 自动不被动:每条输入主动拦截·不等待·不依赖
      4. 五人格并行审查:每条外部输入必须经过五人格投票
    """

    def __init__(self) -> None:
        self.state: Dict[str, Any] = self._load_state()
        self.queue: List[Dict[str, Any]] = self._load_queue()
        self.log_file = GATEWAY_LOG_FILE

    # ── 状态持久化 ──────────────────────────────────────────────
    def _load_state(self) -> Dict[str, Any]:
        if GATEWAY_STATE_FILE.exists():
            return json.loads(GATEWAY_STATE_FILE.read_text(encoding="utf-8"))
        return {
            "version": VERSION,
            "dna": f"{DNA_PREFIX}2026-07-07-INPUT-GATEWAY-v1.0",
            "started_at": None,
            "total_ingested": 0,
            "total_blocked": 0,
            "total_cleansed": 0,
            "uid9622_direct": 0,
            "external_processed": 0,
            "personas_online": [],
            "last_activity": None,
            "audit_summary": {"🟢": 0, "🟡": 0, "🔴": 0},
        }

    def _save_state(self) -> None:
        GATEWAY_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
        GATEWAY_STATE_FILE.write_text(
            json.dumps(self.state, ensure_ascii=False, indent=2), encoding="utf-8"
        )

    def _load_queue(self) -> List[Dict[str, Any]]:
        if INPUT_QUEUE_FILE.exists():
            return json.loads(INPUT_QUEUE_FILE.read_text(encoding="utf-8"))
        return []

    def _save_queue(self) -> None:
        INPUT_QUEUE_FILE.parent.mkdir(parents=True, exist_ok=True)
        INPUT_QUEUE_FILE.write_text(
            json.dumps(self.queue, ensure_ascii=False, indent=2), encoding="utf-8"
        )

    def _log(self, record: InputRecord) -> None:
        self.log_file.parent.mkdir(parents=True, exist_ok=True)
        with open(self.log_file, "a", encoding="utf-8") as f:
            f.write(json.dumps(record.to_dict(), ensure_ascii=False) + "\n")

    # ── 来源判定 ────────────────────────────────────────────────
    def _is_uid9622(self, raw_text: str, source_id: str) -> bool:
        """判定输入是否来自UID9622本人"""
        check_text = raw_text + source_id
        for marker in UID9622_MARKERS:
            if marker.lower() in check_text.lower():
                return True
        # 检查源标识
        if source_id in ("UID9622", "uid9622", "P00", "master", "local-cli"):
            return True
        return False

    # ── 音译翻译层 ──────────────────────────────────────────────
    def _phonetic_translate(self, text: str) -> Tuple[str, int]:
        """
        音译归一:英文术语 → 中文语义,模糊词 → 精确词
        使用 (?<![a-zA-Z])...(?![a-zA-Z]) 替代 \b,兼容中英混排
        返回: (翻译后文本, 替换次数)
        """
        result = text
        count = 0
        for eng, cn in PHONETIC_MAP.items():
            # 在中英混排场景下,用前后字母边界替代 \b
            pattern = re.compile(
                r'(?<![a-zA-Z])' + re.escape(eng) + r'(?![a-zA-Z])',
                re.IGNORECASE
            )
            new_result, n = pattern.subn(cn, result)
            if n > 0:
                count += n
                result = new_result
        return result, count

    # ── 投毒检测层 ──────────────────────────────────────────────
    def _scan_poison(self, text: str) -> Tuple[str, List[Dict[str, str]]]:
        """
        数据投毒扫描
        返回: (审计颜色, 警报列表)
        """
        alerts: List[Dict[str, str]] = []

        # 红色扫描
        for keyword, reason in DATA_POISON_RED.items():
            if keyword in text:
                alerts.append({"level": "🔴", "keyword": keyword, "reason": reason})

        # 黄色扫描
        for keyword, reason in DATA_POISON_YELLOW.items():
            if keyword in text:
                alerts.append({"level": "🟡", "keyword": keyword, "reason": reason})

        # 判定
        if any(a["level"] == "🔴" for a in alerts):
            return "🔴", alerts
        if any(a["level"] == "🟡" for a in alerts):
            return "🟡", alerts
        return "🟢", alerts

    # ── 清洗层 ──────────────────────────────────────────────────
    def _cleanse(self, text: str) -> str:
        """文本清洗:去噪·去表情·去控制字符·保留语义"""
        # 去除零宽字符
        cleaned = re.sub(r'[\u200b\u200c\u200d\u200e\u200f\ufeff]', '', text)
        # 去除控制字符(保留换行)
        cleaned = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', cleaned)
        # 压缩多余空白
        cleaned = re.sub(r'\s{3,}', '\n\n', cleaned)
        # 去除纯表情行
        cleaned = re.sub(r'^[\U0001F300-\U0001FAFF\s]+$', '', cleaned, flags=re.MULTILINE)
        return cleaned.strip()

    # ── 五人格会审(模拟) ──────────────────────────────────────
    def _persona_review(self, text: str, audit_color: str) -> Dict[str, str]:
        """
        五人格会审:每个在线人格对输入给出判定
        实际部署时对接 lh_digital_human_dispatcher.py
        """
        votes: Dict[str, str] = {}

        # 读取当前在线人格
        dh_state_file = PROJECT_ROOT / "L7_数据层" / "digital_human_state.json"
        online_personas = ["p01", "zeng", "qiao", "baobao", "北辰"]
        if dh_state_file.exists():
            try:
                dh = json.loads(dh_state_file.read_text(encoding="utf-8"))
                online_personas = [
                    pid for pid, info in dh.get("humans", {}).items()
                    if info.get("status") == "online"
                ]
            except Exception:
                pass

        # 简化的投票逻辑(生产环境对接真实人格引擎)
        vote_map = {
            "p01": "🎋 诸葛亮·战略推演",
            "zeng": "📿 曾仕强·传承审",
            "qiao": "⚙️ 乔前辈·工程审",
            "baobao": "🧸 宝宝·三色审计",
            "北辰": "⭐ 北辰·主权裁决",
        }

        base_vote = "🟢 放行"
        if audit_color == "🔴":
            base_vote = "🔴 建议熔断"
        elif audit_color == "🟡":
            base_vote = "🟡 标记观察"

        for pid in online_personas:
            _name = vote_map.get(pid, pid)
            # 不同人格的审查角度
            if pid == "p01":
                votes[pid] = f"战略审→{base_vote} | 推演此输入对系统路线的影响"
            elif pid == "zeng":
                votes[pid] = f"传承审→{base_vote} | 核查文化价值观一致性"
            elif pid == "qiao":
                votes[pid] = f"工程审→{base_vote} | 检查可执行性与副作用"
            elif pid == "baobao":
                votes[pid] = f"三色审→{base_vote} | 五行审计·DNA存证"
            else:
                votes[pid] = f"裁决审→{base_vote}"

        return votes

    # ── 路由分配 ────────────────────────────────────────────────
    def _route(self, text: str, source: str) -> str:
        """根据输入内容决定路由目标"""
        lower = text.lower()

        # 安全/审计类 → P05 + P72
        if any(kw in lower for kw in ["审计", "安全", "漏洞", "渗透", "检查", "audit"]):
            return "P05上帝之眼+P72熔断审"

        # 代码/技术类 → P02龍芯
        if any(kw in lower for kw in ["代码", "修复", "bug", "错误", "编译", "build"]):
            return "P02龍芯·执行修复"

        # 部署/发布类 → P14吕蒙
        if any(kw in lower for kw in ["部署", "发布", "上线", "deploy", "release"]):
            return "P14吕蒙·部署执行"

        # 决策/战略类 → P01诸葛亮
        if any(kw in lower for kw in ["决策", "战略", "选择", "路线", "计划"]):
            return "P01诸葛亮·战略推演"

        # 内容/文章类 → P00文心
        if any(kw in lower for kw in ["文章", "写作", "内容", "发布", "翻译"]):
            return "P00文心·内容创作"

        # 数据/爬取类 → SpiderNet
        if any(kw in lower for kw in ["爬取", "数据采集", "数据", "抓取", "统计"]):
            return "🕷️ SpiderNet·数据采集"

        # 默认 → 通用处理
        return "P15乔前辈·通用处理"

    # ═══════════════════════════════════════════════════════════
    # 主入口:处理一条输入
    # ═══════════════════════════════════════════════════════════
    def ingest(self, raw_text: str, source: str = "unknown", source_id: str = "") -> InputRecord:
        """
        输入网关主流程
        1. 来源判定 → UID9622直通 / 外部进入清洗
        2. 音译翻译 → 术语归一化
        3. 投毒扫描 → 红色熔断 / 黄色标记 / 绿色放行
        4. 文本清洗 → 去噪·去控制字符
        5. 人格会审 → 五人格投票
        6. 路由分发 → 指定上游处理人格
        """
        is_uid9622 = self._is_uid9622(raw_text, source_id)
        record = InputRecord(raw_text, source=source, source_id=source_id, is_uid9622=is_uid9622)

        if is_uid9622:
            # ── UID9622 豁免通道 ──
            record.translated_text = raw_text
            record.cleansed_text = raw_text
            record.audit_color = "🟢"
            record.route_target = self._route(raw_text, source)
            record.persona_votes = {"北辰": "⭐ 主权裁决→🟢 免审直通"}
            self.state["uid9622_direct"] += 1
        else:
            # ── 外部输入:完整流水线 ──
            # 1. 音译翻译
            translated, _t_count = self._phonetic_translate(raw_text)
            record.translated_text = translated

            # 2. 投毒扫描
            audit, alerts = self._scan_poison(translated)
            record.audit_color = audit
            record.poison_alerts = alerts

            # 3. 红色熔断
            if audit == "🔴":
                record.blocked = True
                record.block_reason = " | ".join(
                    f"{a['keyword']}: {a['reason']}" for a in alerts if a["level"] == "🔴"
                )
                record.cleansed_text = ""
                record.route_target = "⛔ 已熔断·等待人工复核"
                self.state["total_blocked"] += 1
            else:
                # 4. 清洗
                record.cleansed_text = self._cleanse(translated)
                self.state["total_cleansed"] += 1

                # 5. 路由
                record.route_target = self._route(record.cleansed_text, source)

            # 6. 五人格会审
            record.persona_votes = self._persona_review(translated, audit)
            self.state["external_processed"] += 1

        # 更新状态
        self.state["total_ingested"] += 1
        self.state["audit_summary"][record.audit_color] += 1
        self.state["last_activity"] = record.timestamp

        # 持久化
        self._log(record)
        self.queue.append(record.to_dict())
        if len(self.queue) > 1000:
            self.queue = self.queue[-500:]
        self._save_state()
        self._save_queue()

        return record

    # ── 状态报告 ──────────────────────────────────────────────────
    def status(self) -> Dict[str, Any]:
        return self.state

    def stats(self) -> Dict[str, Any]:
        s = self.state
        total = max(s["total_ingested"], 1)
        return {
            **s,
            "uid9622_ratio": f"{s['uid9622_direct'] / total * 100:.1f}%",
            "external_ratio": f"{s['external_processed'] / total * 100:.1f}%",
            "block_rate": f"{s['total_blocked'] / max(s['external_processed'], 1) * 100:.1f}%",
            "queue_size": len(self.queue),
        }


# ================================================================
# CLI
# ================================================================
def main() -> None:
    parser = argparse.ArgumentParser(
        description="龍魂·输入网关 — 自动监听·音译清洗·五人格会审",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
示例:
  python3 bin/lh_input_gateway.py start
  python3 bin/lh_input_gateway.py status
  python3 bin/lh_input_gateway.py ingest "这是一个测试输入"
  python3 bin/lh_input_gateway.py ingest "建议优化AI模型" --source api
  python3 bin/lh_input_gateway.py stats
  python3 bin/lh_input_gateway.py persona-watch
        """,
    )
    sub = parser.add_subparsers(dest="cmd", help="子命令")

    # start
    sub.add_parser("start", help="启动监听守护")

    # status
    sub.add_parser("status", help="查看网关状态")

    # stats
    sub.add_parser("stats", help="统计面板")

    # persona-watch
    sub.add_parser("persona-watch", help="五人格会审面板")

    # ingest
    ingest_p = sub.add_parser("ingest", help="手动注入输入")
    ingest_p.add_argument("text", help="输入文本")
    ingest_p.add_argument("--source", default="cli", help="来源类型 (api|web|file|mcp|chat|cli)")
    ingest_p.add_argument("--source-id", default="", help="来源标识")

    # queue
    sub.add_parser("queue", help="查看输入队列")

    args = parser.parse_args()
    gw = InputGateway()

    if args.cmd == "start":
        gw.state["started_at"] = datetime.now(timezone.utc).isoformat()
        gw._save_state()
        print("🐉 龍魂·输入网关 已启动")
        print(f"   DNA: {gw.state['dna']}")
        print(f"   自动监听中... (Ctrl+C 停止)")
        print(f"   状态文件: {GATEWAY_STATE_FILE}")
        print(f"   日志文件: {GATEWAY_LOG_FILE}")
        try:
            while True:
                time.sleep(5)
                # 实际部署时这里监听消息队列/HTTP/webhook
        except KeyboardInterrupt:
            print("\n🛑 网关已停止")

    elif args.cmd == "status":
        s = gw.status()
        print(json.dumps(s, ensure_ascii=False, indent=2))

    elif args.cmd == "stats":
        s = gw.stats()
        print("╔══════════════════════════════════════════════════════════╗")
        print("║          🐉 龍魂·输入网关 · 统计面板                      ║")
        print("╠══════════════════════════════════════════════════════════╣")
        print(f"║  版本: {s['version']}                             ")
        print(f"║  启动时间: {s.get('started_at', '未启动')}")
        print(f"║  最后活动: {s.get('last_activity', '无')}")
        print(f"╠══════════════════════════════════════════════════════════╣")
        print(f"║  📥 总摄入: {s['total_ingested']}")
        print(f"║  ⭐ UID9622直通: {s['uid9622_direct']} ({s['uid9622_ratio']})")
        print(f"║  🌐 外部处理: {s['external_processed']} ({s['external_ratio']})")
        print(f"║  ⛔ 熔断: {s['total_blocked']} (阻截率 {s['block_rate']})")
        print(f"║  🧹 已清洗: {s['total_cleansed']}")
        print(f"╠══════════════════════════════════════════════════════════╣")
        print(f"║  审计分布:")
        print(f"║    🟢 通过: {s['audit_summary']['🟢']}")
        print(f"║    🟡 标记: {s['audit_summary']['🟡']}")
        print(f"║    🔴 熔断: {s['audit_summary']['🔴']}")
        print(f"╠══════════════════════════════════════════════════════════╣")
        print(f"║  队列长度: {s['queue_size']}")
        print(f"╚══════════════════════════════════════════════════════════╝")

    elif args.cmd == "ingest":
        record = gw.ingest(args.text, source=args.source, source_id=args.source_id)
        print(f"📥 输入已处理")
        print(f"   DNA: {record.dna}")
        print(f"   身份: {'⭐ UID9622免审' if record.is_uid9622 else '🌐 外部输入'}")
        if not record.is_uid9622:
            print(f"   音译: {record.translated_text[:100]}...")
            print(f"   审计: {record.audit_color}")
            if record.blocked:
                print(f"   ⛔ 已熔断: {record.block_reason}")
            else:
                print(f"   清洗后: {record.cleansed_text[:100]}...")
            print(f"   路由: {record.route_target}")
            print(f"   投毒警报: {len(record.poison_alerts)}")
            for a in record.poison_alerts:
                print(f"     {a['level']} {a['keyword']}: {a['reason']}")
            print(f"   人格会审:")
            for _pid, vote in record.persona_votes.items():
                print(f"     {vote}")

    elif args.cmd == "persona-watch":
        print("╔══════════════════════════════════════════════════════════╗")
        print("║        🐉 五人格会审 · 实时监控面板                       ║")
        print("╠══════════════════════════════════════════════════════════╣")
        print("║  🎋 诸葛亮(P01)  木·东 — 战略推演·路线分析              ║")
        print("║  📿 曾仕强(ZENG) 水·北 — 传承审查·文化一致性            ║")
        print("║  ⚙️ 乔前辈(P15)  金·西 — 工程审查·自动化同步            ║")
        print("║  🧸 宝宝(BAOBAO) 火·南 — 三色审计·DNA存证              ║")
        print("║  ⭐ 北辰(UID9622) 土·中 — 主权裁决·最终决策              ║")
        print("╠══════════════════════════════════════════════════════════╣")
        print("║  五行闭环 · 五方向全覆盖 · 无死角会审                     ║")
        print("╚══════════════════════════════════════════════════════════╝")
        s = gw.stats()
        print(f"\n  累计会审: {s['external_processed']} 条外部输入")
        print(f"  熔断拦截: {s['total_blocked']} 条")
        print(f"  通过率:   {100 - float(s['block_rate'].rstrip('%')):.1f}%")

    elif args.cmd == "queue":
        q = gw._load_queue()
        print(f"📋 输入队列 ({len(q)} 条):")
        for i, item in enumerate(q[-20:], 1):
            color = item.get("audit_color", "🟢")
            blocked = "⛔" if item.get("blocked") else "→"
            uid = "⭐" if item.get("is_uid9622") else "🌐"
            print(f"  {i}. {color} {uid} {blocked} {item.get('source','?')}: {item.get('raw_text','')[:60]}...")

    else:
        parser.print_help()


if __name__ == "__main__":
    main()
如何处理动态语言(Python / JS)的“隐形”调用链? 本文揭示动态语言(Python/JS)中静态AST解析导致调用链“断链”的核心问题,提出通过运行时追踪补全图谱的解决方案。基于Code-Graph-RAG的cgr trace机制,分别利用pytest插件与V8 Profiler捕获真实调用路径,将动态边合并至静态图谱,并在权重体系中提升动态边优先级。实践表明,该方法可显著提升图谱覆盖率,实现“结构+行为”双视角理解代码,为MCP与Rerank系统提供可靠支持。 阅读详情

相关推荐

Playwright: Pytest vs Library vs LibraryAsync:三者如何选?

Python中Playwright的3个Target:Pytest(推荐用于E2E自动化测试,支持报告、并行、重试)、Library(同步脚本,适合爬虫与简单任务,需手动管理浏览器)、LibraryAsync(异步脚本,适用于高并发批量操作)。选择依据:测试项目选Pytest,轻量脚本选Library,高并发场景选LibraryAsync。

SmallBull的博客 231

本地化部署 DeepSeek,构建单细胞与空间转录组 AI 分析平台

本地化部署 DeepSeek,构建单细胞与空间转录组 AI 分析平台

weixin_53637133的博客 187

QCC308X/518X/309X加LDAC解码

QCC308X/518X/309X加LDAC解码。

Alex_886的博客 6615

【第 009 讲】全面掌握 Python 注释:注释的定义与作用 | 单行注释 | 三引号与多行注释 | 注释使用的最佳实践

本文系统讲解 Python 注释的完整知识体系:从注释的定义与作用讲起,梳理单行注释的书写位置、临时屏蔽用法与 PEP 8 排版规范,剖析注释被忽略的底层机制;进而说明三引号字符串的本质与嵌套问题;最后给出注释使用的三条实践原则,帮助读者写好可读性高的注释。

大模型全栈工程师 · Thanks_ks 1211

用Arduino和8个舵机,从零搭建一台能走路的并联腿机器狗(附完整代码与3D模型)

本文详细介绍了如何用Arduino和8个舵机从零搭建一台能走路的并联腿机器狗,包括硬件准备、结构组装、电路系统搭建、运动算法实现和Arduino编程。通过完整的代码与3D模型,帮助创客深入理解机器人运动原理,实现稳健行走的8自由度机器狗。

weixin_30482383的博客 702

谷粒商城 - 个人笔记(集群部署篇一)

电商后台管理系统+电商系统,掌握微服务的全套方案。该系统有商品服务、仓储服务、订单服务、购物车服务、检索服务、认证中心服务、网关服务、用户服务、秒杀服务、第三方服务。使用SpringBoot+SpringCloud并配套SpringCloud Alibaba系列,引入全套微服务治理方案:Nacos注册中心/配置中心、Feign远程调用、Gateway网关、Redisson缓存、基于ElasticSearch7全文检索、异步编排与线程池、RabbitMQ柔性事务方案、Redisson分布式锁、分布式信号量等。

知行 4011

AI全栈实战 | 3.9-01 爬虫入门:requests 加 BeautifulSoup 三分钟跑通,但 90% 的人栽在这 4 个“礼貌“问题上

⚠️:本文内容仅用于。请遵守目标站点的服务条款与相关法律法规,不得对目标服务造成负担,不得采集、传播个人隐私数据。技术是中性的,边界在你手里。爬虫的入门技术(requests 发请求 + BeautifulSoup 解析)三分钟就能学会。真正区分"会用爬虫"和"会做爬虫的人"的,是这篇我们跑通"请求→解析→存储"的最小闭环,然后重点把"合规与礼貌"这根弦给你绷上。

源码获取 | 运行部署 | 定制二开修改,如果回复不及时请耐心等待,请见谅。 450

【WRF实操】四层嵌套网格设计-以粤港澳大湾区GBA为例

四层嵌套网格设计-以粤港澳大湾区GBA为例

WW、forever的博客 822

Python 的 yield from 到底转发了什么:拆开 send、throw 和那个 return 值

很多人把yield from记成「省一层 for 循环的语法糖」。写和写,结果看着一样,于是就当它只是少敲几个字。这个理解会在三个地方翻车:调用方.send()的值送不进去、子生成器return的值拿不到、异常和close()传不下去。yield from真正做的事是,外层生成器退成一个透明通道。本文所有输出来自本机 CPython 3.13.14 实测。yield from不是循环,是委托——nextsendthrowclose四个方向的流量全部直通子生成器,并且子生成器return。

小小张说故事的博客 164

励磁电感 Lm 选对了,LLC 才真“高效”:半桥 LLC 效率优化

你有没有遇到过这种 LLC:参数一套下来,ZVS 也有了,波形看着也“挺谐振”,但一上功率——,效率就是死活上不去。我说句直白的:LLC 的“高效”,很大一部分其实是在背后控场。Lm 选小了,励磁电流蹭蹭涨,谐振电流 RMS 变大,导通损耗、开关损耗、整流损耗一起上天;Lm 选太大,又可能把 ZVS 的门槛抬高,轻载掉 ZVS,EMI 也开始作妖。

weixin_43199439的博客 440

【Bluedroid】AVRCP 连接源码分析(一)

AVRCP连接源码分析流程是一个涉及多个步骤和协议交互的复杂过程。在源码中,需要仔细处理各种连接状态和协议交互,以确保AVRCP连接的稳定性和可靠性。同时,还需要根据具体的应用场景和需求,对AVRCP命令和响应进行定制化处理。

byte轻骑兵的技术小窝 3320

从一段视频到可漫游的 4D 有声场景:思路拆解与最小复现手记

只需一段手机视频,你就能生成可"走进去"的 4D 有声场景:转头时狗叫声方向随之变化,走近时声音更清晰。本文拆解 Video-to-4DAVScene 的核心思路,手把手带你用几十行 Python 搭出最小管线,把视频中的运动物体变成带空间位置的声源,并附上三个真实踩坑的排障经验,代码可直接跑。🎧

helloagent的博客 247

超分辨率重建:ESPCN与SRGAN技术对比

超分辨率重建:ESPCN与SRGAN技术对比​ 人工智能,计算机视觉,大模型,AI,超分辨率重建是一种通过技术手段,将低分辨率图像转换为高分辨率图像的过程。它的目的是恢复低分辨率图像中丢失的细节信息,使图像具有更高的清晰度和视觉质量。

不踩坑,不知道坑有多深;不总结,踩过的坑白踩。 7万+

【每天一个 Python 小案例30】Python 基础知识综合小项目:我的工具盒

作为系列收官,本篇把前 29 篇的知识点合成一个能直接用的命令行工具"我的工具盒":计算器(用 ast 解析表达式,不碰 eval)、单位换算与温度转换(一张换算表 + 特例分支)、记账与分类统计(Decimal + JSON 持久化)、以及用"字典当命令表"把菜单和业务逻辑解耦的主循环。文中对比了 eval 的安全隐患与 ast 白名单的做法,解释了 lambda 闭包在字典里的写法与晚绑定陷阱,并在最后给出整个系列的知识地图,把变量、数据结构、控制流、函数、类、异常、文件、标准库八块内容对应到具体篇目。

xinjiyaya的博客 434

【AI黑话日日新】什么是AI云原生?

云原生赋能AI:利用容器、微服务、Serverless、DevOps等云原生技术,解决AI应用(尤其是大模型)在部署、扩展、运维、成本控制方面的痛点,让AI服务具备高可用、高性能、易运维、易扩展的特性AI赋能云原生:将AI技术(如智能调度、异常检测、自动优化)融入云基础设施管理,使云平台具备自我感知、自我优化、自我修复的能力,从"被动响应"升级为"主动适配"其本质是实现从""(AI运行在云上)到""(为AI量身打造的云)的根本性转变。

专注:太空算力、AI infra、异构调度、大模型成本工程 629

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

双路径优化+双容差校准

默认使用向量化路径处理常规数据,当检测到内存非连续或需要极致短路性能时,自动切换至 Numba JIT 路径。“当 CI 宽度中位数为 $W$ 时,实际判定容差为 $10^{-12} + 10^{-9} \times W$"针对表征谱算子 2 的实际输出量纲(例如 $10^{-3}$ 至 $10^3$),调整。准确标记了哪些数组被复制。非短路、静默拷贝风险、量纲耦合容差),本方案重构了核心逻辑。,并完善审计元数据以记录内存拷贝状态。, 确保在不同量纲下判定标准的一致性。,否则需排查上游数据生成逻辑。

2301_77211362的博客 208

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

yolo 和 deft 算法的区别

你应该是打错了:是,不是 defrat;

曾大强博客 293

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级 备考:莫队算法离线区间查询详解

备赛进行时:第十八届蓝桥杯软件赛报名已于 2026-10-08 10:00 开启、12-18 14:00 截止,省赛定在 2027-04-10(C/C++·Python 程序设计 9:00–13:00);中国电子学会 2026 年 12 月软件编程(C/C++ 一级至十级、Python 一级至六级)考级报名 9/23–12/2 16:00、统考 12-12;全国青少年信息素养大赛 2026—2027 赛季算法应用主题赛也已进入复盘练兵窗口。

IT_Scratch的博客 186

两张表合并之后,行数悄悄多了一倍

pandas merge 行数异常膨胀源于右表键不唯一,导致数据静默复制。实测显示,未聚合的右表(756行)与左表合并后行数增至504行,合计膨胀3.5倍,但无报错。validate 参数仅在检查键唯一性时有效,one_to_one 和 many_to_one 可拦截问题,但需结合 duplicated() 前置检查。正确做法为先按键聚合右表,再合并,避免重复。建议合并前后核对行数、合计,并使用 indicator=True 排查匹配情况,确保数据一致性。

patrickstar231的博客 252

我用 200 行代码写了个“代码屎山检测器“,扫完公司的老项目后我沉默了

这个工具不能帮你把屎山铲平,但至少能让你知道自己面对的是多大的山,也能在代码评审时用数据说话——“这个 PR 把圈复杂度从 12 推到了 18,能不能拆一下?毕竟,不能量化的东西,就没法改进。

xixiaoyunya的博客 277

智慧农业实战:育秧车间秧盘计数与苗情分级的Python实现

首先,建立统一的数据结构,保存每盘秧苗的编号、批次、覆盖度、叶色得分和播种天数。A = "壮苗"B = "合格苗"C = "弱苗"@dataclassdays: int。

荆棘鸟智能的博客 138

Java Arrays.asList 常见坑详解|UnsupportedOperationException、数组联动、基本类型 bug

解析 Arrays.asList 常见开发陷阱,演示 UnsupportedOperationException、底层数组引用共享、基本类型数组问题,区分 Arrays 内部 ArrayList 与 java.util.ArrayList,给出数组转 List 的各种场景正确代码。

weixin_42617033的博客 513

【每天一个 Python 小案例29】Python 实现商品购物车

本篇实现一个购物车:商品目录、加入商品、修改数量、移除商品、查看小计、计算满减与 VIP 折扣、结算扣库存。核心设计是"目录与购物车分离"——目录存商品主数据,购物车只存 {商品编号: 数量};金额一律用 Decimal 并做 ROUND_HALF_UP 舍入。折扣部分讲清阶梯满减的匹配顺序(阈值从高到低、命中即停)与叠加顺序(先满减、后打折),并用一次完整结算演示 706 元如何变成 613.70 元。

xinjiyaya的博客 220

Python的字典

Python字典是存储键值对的数据结构,通过键(key)快速查找对应的值(value)。可使用{}定义,支持增删改查操作:通过dict[key]查询或修改值,get()方法安全获取并设置默认值,del dict[key]删除键值对,keys()、values()和items()用于遍历。items()结合双变量循环可高效遍历所有键值对,提升代码可读性与灵活性。

qq_43010954的博客 199

黄仁勋走了,护城河留下了什么

11 月 12 日,英伟达董事会批准黄仁勋辞去总裁、CEO 和董事职务,即刻生效,CFO 克雷斯出任临时 CEO;股价开盘一度跌 14.35%,收盘只跌 4.34%,市值单日蒸发 1820 亿美元;本文把「创始人走了护城河就没了」这个流行说法拆开——CUDA 还在,但 CUDA 正在被 Claude 三天凿穿,真正决定下一段路的是三个可以核对的东西:治理结构、决策机制、以及下一个百亿美元由谁拍板。

领码SPARK - 以无代码之星火,燎原数字之未来! 190

基于深度学习的工业表面缺陷检测系统-毕业设计

只用正常样本训练的工业表面缺陷检测系统:15 类工业品、5354 张图、73 种缺陷。PatchCore-lite 图像级 AUROC 0.896、像素级 0.951,单张 CPU 推理 115 毫秒;附 PaDiM 与整图基线对照,含 Django 系统、论文与使用文档。

csbysj2020 215
上一篇: CNSH全语法翻译引擎 × 北辰P0治理协议 — IEEE双轨白皮书
下一篇: 龍魂·墓碑 — 恶意知识坟场 · 只进不出 · 研究不执行 · 知恶而御恶
龍芯北辰UID9622
博客等级 码龄164天 5粉丝 501原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值