"""
大模型数字计算Skill基础示例
核心功能：接收自然语言计算需求，提取表达式并计算，返回自然语言答案
"""
# ===================== 第一步：定义Skill的核心配置（告诉"大模型"这个Skill能做什么） =====================
# Skill描述：相当于给Skill写"说明书"，让大模型知道它能解决什么问题、需要什么参数
calculator_skill_manifest = {
    "name": "simple_calculator",  # Skill名称
    "description": "解决简单的数字计算问题，支持加减乘除，输入为数学表达式（如3+5、10-4*2）",  # Skill功能说明
    "parameters": {
        "expression": {  # 所需参数：计算表达式
            "type": "string",
            "description": "需要计算的数学表达式，仅包含数字和+-*/，如3+5、10/2"
        }
    }
}
# ===================== 第二步：实现参数提取逻辑（从用户输入中提取计算表达式） =====================
def extract_calculation_expression(user_input):
    """
    从用户自然语言输入中提取计算表达式（极简实现，新手易理解）
    参数：user_input - 用户输入的自然语言（如"帮我算3加5乘2"）
    返回：提取出的数学表达式（如"3+5*2"），提取失败返回空字符串
    """
    # 第一步：替换自然语言中的加减乘除为符号（核心：把"加"→"+"，"减"→"-"等）
    replace_map = {
        "加": "+",
        "减": "-",
        "乘": "*",
        "除": "/",
        "乘以": "*",
        "除以": "/",
        "等于": "",  # 去掉"等于"这类无意义词汇
        "的结果": "",
        "帮我算": "",
        "计算": ""
    }
    
    # 替换用户输入中的文字
    processed_input = user_input
    for word, symbol in replace_map.items():
        processed_input = processed_input.replace(word, symbol)
    
    # 第二步：提取仅包含数字和+-*/的表达式（过滤无关文字）
    import re
    # 正则表达式：匹配数字、+-*/组成的连续字符串
    pattern = r"[0-9\+\-\*\/]+"
    matches = re.findall(pattern, processed_input)
    
    # 返回第一个匹配到的表达式（如用户输入"3加5乘2等于多少"，返回"3+5*2"）
    return matches[0] if matches else ""
# ===================== 第三步：实现Skill核心计算逻辑 =====================
def calculator_skill_core(expression):
    """
    计算Skill的核心逻辑：执行数学表达式计算
    参数：expression - 提取出的数学表达式（如"3+5*2"）
    返回：计算结果（成功）/错误信息（失败）
    """
    try:
        # 安全执行表达式计算（新手注意：eval需谨慎，生产环境需限制表达式范围）
        # 这里仅用于基础示例，聚焦Skill逻辑而非安全问题
        result = eval(expression)
        return {
            "status": "success",  # 执行状态：成功/失败
            "expression": expression,  # 计算的表达式
            "result": result  # 计算结果
        }
    except ZeroDivisionError:
        return {
            "status": "error",
            "message": "除数不能为0"
        }
    except Exception as e:
        return {
            "status": "error",
            "message": f"计算失败：{str(e)}"
        }
# ===================== 第四步：实现大模型交互逻辑（模拟大模型调用Skill） =====================
def llm_with_calculator_skill(user_input):
    """
    模拟大模型调用计算Skill的完整流程
    参数：user_input - 用户输入的自然语言
    返回：最终的自然语言回答
    """
    # 1. 打印Skill说明书（模拟大模型读取Skill配置）
    print("=== 大模型读取Skill配置 ===")
    print(f"Skill名称：{calculator_skill_manifest['name']}")
    print(f"Skill功能：{calculator_skill_manifest['description']}")
    
    # 2. 提取计算表达式（模拟大模型解析用户需求）
    print("\n=== 大模型解析用户需求 ===")
    expression = extract_calculation_expression(user_input)
    if not expression:
        return "抱歉，我没看懂你要计算的内容，请输入如'3加5'的格式"
    print(f"提取到的计算表达式：{expression}")
    
    # 3. 调用计算Skill（核心步骤）
    print("\n=== 调用计算Skill ===")
    skill_result = calculator_skill_core(expression)
    
    # 4. 生成自然语言回答（模拟大模型整理Skill结果）
    print("\n=== 大模型整理结果 ===")
    if skill_result["status"] == "success":
        return f"你要计算的表达式是{skill_result['expression']}，结果是{skill_result['result']}"
    else:
        return f"计算出错：{skill_result['message']}"
# ===================== 第五步：测试示例 =====================
if __name__ == "__main__":
    # 示例1：基础加法
    user_input1 = "帮我算3加5的结果"
    print("用户输入：", user_input1)
    print("最终回答：", llm_with_calculator_skill(user_input1))
    print("-" * 50)
    
    # 示例2：带乘除的混合运算
    user_input2 = "10减4乘2等于多少"
    print("用户输入：", user_input2)
    print("最终回答：", llm_with_calculator_skill(user_input2))
    print("-" * 50)
    
    # 示例3：错误场景（除数为0）
    user_input3 = "8除以0的结果是多少"
    print("用户输入：", user_input3)
    print("最终回答：", llm_with_calculator_skill(user_input3))

calculator_skill_manifest = {
    "name": "simple_calculator",
    "description": "解决简单的数字计算问题...",
    "parameters": {...}
}

def extract_calculation_expression(user_input):
    replace_map = {"加": "+", "减": "-"...}
    # 替换文字为符号 → 提取表达式

def calculator_skill_core(expression):
    try:
        result = eval(expression)
        return {"status": "success", "result": result}
    except:
        return {"status": "error", "message": "..."}

def llm_with_calculator_skill(user_input):
    # 读取Skill配置 → 提取参数 → 调用Skill → 生成回答

"""
基于本地Qwen1.5-1.8B-Chat模型实现文本关键词提取Skill
核心功能：接收自然语言输入，提取指定数量的文本关键词，返回结构化结果+自然语言回答
"""
from transformers import AutoTokenizer, AutoModelForCausalLM
from modelscope import snapshot_download
import re
import os
# ===================== 第一步：加载本地Qwen1.5模型（复用你的基础代码） =====================
def load_local_qwen_model():
    """加载本地Qwen1.5模型和Tokenizer"""
    model_name = "qwen/Qwen1.5-1.8B-Chat"
    cache_dir = "D:\\modelscope\\hub"
    print("正在加载本地Qwen1.5模型...")
    # 直接使用本地缓存路径（注意：modelscope会替换点号为三个下划线）
    local_model_path = f"{cache_dir}\\qwen\\Qwen1___5-1___8B-Chat"
    # 检查本地模型是否存在
    if not os.path.exists(local_model_path):
        print(f"本地模型路径不存在：{local_model_path}")
        print("尝试使用 snapshot_download 下载...")
        # 下载/校验模型（已下载则直接读取缓存）
        local_model_path = snapshot_download(model_name, cache_dir=cache_dir)
    else:
        print(f"使用本地模型：{local_model_path}")
    # 初始化Tokenizer和Model
    tokenizer = AutoTokenizer.from_pretrained(local_model_path, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(
        local_model_path,
        trust_remote_code=True,
        device_map="auto"  # 自动适配CPU/GPU（无GPU则用CPU运行）
    )
    print("本地Qwen1.5模型加载完成！")
    return tokenizer, model
# 全局加载模型（避免重复加载）
tokenizer, model = load_local_qwen_model()
# ===================== 第二步：定义关键词提取Skill的配置（Skill说明书） =====================
keyword_extract_skill = {
    "name": "keyword_extract_skill",
    "description": "提取文本中的核心关键词，支持指定关键词数量，输出结构化的关键词列表",
    "parameters": {
        "text": {
            "type": "string",
            "required": True,
            "description": "需要提取关键词的原始文本内容"
        },
        "num": {
            "type": "int",
            "required": False,
            "default": 5,
            "description": "需要提取的关键词数量，默认提取5个"
        }
    }
}
# ===================== 第三步：解析用户输入参数（从自然语言中提取文本和数量） =====================
def parse_keyword_parameters(user_input):
    """
    从用户自然语言输入中提取文本和关键词数量参数
    示例：
    - 用户输入："提取这段文字的3个核心关键词：人工智能技术正在改变各行各业的发展格局"
    - 输出：{"text": "人工智能技术正在改变各行各业的发展格局", "num": 3}
    """
    # 初始化默认参数
    params = {
        "text": "",
        "num": keyword_extract_skill["parameters"]["num"]["default"]  # 默认5个
    }
    
    # 1. 提取关键词数量（匹配数字+个/条/个核心等）
    num_pattern = r"(\d+)个.*关键词|关键词.*(\d+)个|(\d+)条.*关键词|关键词.*(\d+)条"
    num_matches = re.findall(num_pattern, user_input)
    if num_matches:
        # 提取第一个匹配到的数字
        num_str = [m for m in num_matches[0] if m][0]
        params["num"] = int(num_str)
    
    # 2. 提取需要分析的文本（冒号后/关键词：后的内容）
    text_pattern = r"关键词[:：](.*)"
    text_matches = re.findall(text_pattern, user_input)
    if text_matches:
        params["text"] = text_matches[0].strip()  # 去除首尾空格
    # 兜底：如果没有冒号，取输入中除了数量描述外的所有内容
    elif not params["text"]:
        # 移除数量相关描述
        clean_input = re.sub(num_pattern, "", user_input)
        clean_input = clean_input.replace("提取", "").replace("核心", "").replace("关键词", "").strip()
        params["text"] = clean_input
    
    return params
# ===================== 第四步：实现关键词提取Skill核心逻辑 =====================
def keyword_extract_core(params):
    """
    Skill核心逻辑：调用本地Qwen1.5模型提取关键词
    参数：params - 包含text和num的字典
    返回：结构化结果（成功/失败+关键词列表）
    """
    # 校验参数
    if not params["text"]:
        return {
            "status": "error",
            "message": "未提取到需要分析的文本，请检查输入格式（如：提取这段文字的3个关键词：人工智能改变世界）"
        }
    
    # 构建提示词（Prompt Engineering）
    prompt = f"""
    请完成以下任务：
    1. 分析文本：{params['text']}
    2. 提取{params['num']}个核心关键词，要求：
       - 关键词为中文，简洁（1-4个字）
       - 能准确反映文本核心内容
       - 用逗号分隔关键词
    3. 仅返回关键词列表，不要额外解释
    """
    
    try:
        # 调用本地Qwen1.5模型
        # 构建Chat格式（Qwen模型要求的格式）
        messages = [{"role": "user", "content": prompt}]
        print(f"构建消息完成，prompt长度：{len(prompt)}")
        # 应用chat模板
        text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True
        )
        print(f"Chat模板应用完成，文本长度：{len(text)}")
        # 转换为tensor
        input_ids = tokenizer(
            text,
            return_tensors="pt",
            padding=True,
            truncation=True
        ).input_ids.to(model.device)
        print(f"Tokenization完成，input_ids shape: {input_ids.shape}")
        # 生成结果（控制生成长度和随机性）
        outputs = model.generate(
            input_ids,
            max_new_tokens=100,  # 最大生成100个token
            do_sample=False,    # 关闭采样，保证结果稳定
            temperature=1.0,    # 温度参数（do_sample=False时无效）
            top_p=None          # 明确禁用top_p（避免警告）
        )
        print(f"生成完成，outputs shape: {outputs.shape}")
        # 解析生成结果
        response = tokenizer.decode(outputs[0][input_ids.shape[1]:], skip_special_tokens=True)
        print(f"解码完成，原始响应：{response}")
        # 处理结果：按逗号分割为关键词列表
        # 先尝试中文逗号，再尝试英文逗号
        if "，" in response:
            keywords = [k.strip() for k in response.split("，") if k.strip()]
        elif "," in response:
            keywords = [k.strip() for k in response.split(",") if k.strip()]
        else:
            # 如果没有逗号，尝试按换行符分割
            keywords = [k.strip() for k in response.split("\n") if k.strip()]
        # 过滤掉明显不是关键词的内容（如序号、标点等）
        keywords = [k for k in keywords if k and len(k) > 0 and k not in ["1.", "2.", "3.", "4.", "5.", "1、", "2、", "3、", "4、", "5、"]]
        # 确保关键词数量符合要求（不足则补全，过多则截断）
        if len(keywords) > params["num"]:
            keywords = keywords[:params["num"]]
        elif len(keywords) < params["num"]:
            # 如果提取的关键词数量不足，用空字符串补全
            keywords.extend([""] * (params["num"] - len(keywords)))
        print(f"关键词提取完成：{keywords}")
        return {
            "status": "success",
            "text": params["text"],
            "num": params["num"],
            "keywords": keywords
        }
    except Exception as e:
        import traceback
        error_detail = traceback.format_exc()
        print(f"错误详情：\n{error_detail}")
        return {
            "status": "error",
            "message": f"关键词提取失败：{str(e)}"
        }
# ===================== 第五步：Skill调用主函数 =====================
def call_keyword_extract_skill(user_input):
    """
    调用关键词提取Skill的完整流程
    参数：user_input - 用户自然语言输入
    返回：自然语言回答
    """
    print("=== 1. 解析用户输入参数 ===")
    params = parse_keyword_parameters(user_input)
    print(f"解析结果：{params}")
    
    print("\n=== 2. 执行关键词提取Skill ===")
    skill_result = keyword_extract_core(params)
    
    print("\n=== 3. 生成最终回答 ===")
    if skill_result["status"] == "success":
        answer = f"""
        已为你提取文本的核心关键词：
        原始文本：{skill_result['text']}
        提取数量：{skill_result['num']}个
        关键词：{', '.join(skill_result['keywords'])}
        """
    else:
        answer = skill_result["message"]
    
    return answer
# ===================== 测试示例 =====================
if __name__ == "__main__":
    # 测试用例1：基础用法
    test_input1 = "提取这段文字的3个核心关键词：人工智能技术正在改变各行各业的发展格局"
    print("测试用例1输入：", test_input1)
    print("测试用例1输出：", call_keyword_extract_skill(test_input1))
    print("-" * 80)
    
    # 测试用例2：默认数量（5个）
    test_input2 = "提取关键词：大模型Skill是模块化的能力单元，能弥补通用大模型的场景化短板"
    print("测试用例2输入：", test_input2)
    print("测试用例2输出：", call_keyword_extract_skill(test_input2))
    print("-" * 80)
    
    # 测试用例3：异常输入（无文本）
    test_input3 = "帮我提取5个关键词"
    print("测试用例3输入：", test_input3)
    print("测试用例3输出：", call_keyword_extract_skill(test_input3))

def load_local_qwen_model():
    local_model_path = snapshot_download(model_name, cache_dir=cache_dir)
    tokenizer = AutoTokenizer.from_pretrained(local_model_path, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(...)

keyword_extract_skill = {
    "name": "keyword_extract_skill",
    "description": "提取文本中的核心关键词...",
    "parameters": {...}
}

def parse_keyword_parameters(user_input):
    num_pattern = r"(\d+)个.*关键词..."  # 匹配数量
    text_pattern = r"关键词[:：](.*)"     # 匹配文本

def keyword_extract_core(params):
    # 构建提示词 → 调用模型 → 解析结果
    prompt = f"分析文本：{params['text']}，提取{params['num']}个核心关键词..."
    messages = [{"role": "user", "content": prompt}]
    input_ids = tokenizer.apply_chat_template(messages, ...)
    outputs = model.generate(...)

def call_keyword_extract_skill(user_input):
    params = parse_keyword_parameters(user_input)  # 解析参数
    skill_result = keyword_extract_core(params)    # 执行Skill
    # 生成自然语言回答