pro-craft 0.1.56__tar.gz → 0.2.58__tar.gz

{pro_craft-0.1.56 → pro_craft-0.2.58}/PKG-INFO

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: pro-craft
-Version: 0.1.56
+Version: 0.2.58
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: aiomysql>=0.2.0
 Requires-Dist: anyio>=4.11.0
 Requires-Dist: db-help>=0.2.2
+Requires-Dist: deepagents>=0.2.4
 Requires-Dist: fastapi>=0.119.0
+Requires-Dist: langchain-openai>=1.0.2
 Requires-Dist: llmada>=1.1.11
 Requires-Dist: mcp[cli]>=1.19.0
 Requires-Dist: modusched==0.1.5
@@ -51,3 +53,7 @@ await ctx.elicit(message, schema) - Request additional information from user wit
 ```
 
 
+
+## 做到prompt_writing_herper 中 目标是, 无论什么, 随便扔进去, 然后取的时候直接取即可
+
+## 然后做code自动化编写的coder 写完之后写豆包语音智能体的链接, mcp协议 然后重构一些, obsidian 的SDK

{pro_craft-0.1.56 → pro_craft-0.2.58}/README.md

@@ -32,3 +32,7 @@ await ctx.elicit(message, schema) - Request additional information from user wit
 ```
 
 
+
+## 做到prompt_writing_herper 中 目标是, 无论什么, 随便扔进去, 然后取的时候直接取即可
+
+## 然后做code自动化编写的coder 写完之后写豆包语音智能体的链接, mcp协议 然后重构一些, obsidian 的SDK

{pro_craft-0.1.56 → pro_craft-0.2.58}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "pro-craft"
-version = "0.1.56"
+version = "0.2.58"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
-dependencies = [ "aiomysql>=0.2.0", "anyio>=4.11.0", "db-help>=0.2.2", "fastapi>=0.119.0", "llmada>=1.1.11", "mcp[cli]>=1.19.0", "modusched==0.1.5", "plotly>=6.3.1", "pyyaml>=6.0.3", "toml>=0.10.2", "utils-tool==0.1.3", "uvicorn>=0.38.0",]
+dependencies = [ "aiomysql>=0.2.0", "anyio>=4.11.0", "db-help>=0.2.2", "deepagents>=0.2.4", "fastapi>=0.119.0", "langchain-openai>=1.0.2", "llmada>=1.1.11", "mcp[cli]>=1.19.0", "modusched==0.1.5", "plotly>=6.3.1", "pyyaml>=6.0.3", "toml>=0.10.2", "utils-tool==0.1.3", "uvicorn>=0.38.0",]
 
 [tool.setuptools.package-data]
 pro_craft = [ "config.yaml",]

{pro_craft-0.1.56 → pro_craft-0.2.58}/src/pro_craft/__init__.py

@@ -1,18 +1,10 @@
-
-
-
 from dotenv import load_dotenv, find_dotenv
-
 dotenv_path = find_dotenv()
 load_dotenv(".env", override=True)
-
-from .log import Log
 import logging
-Log_ = Log(console_level = logging.WARNING, # 显示控制台的等级
+from .log import Log
+Log_ = Log(console_level = logging.WARNING, # 显示控制台的等级 WARNING
              log_file_name="app.log")
 logger = Log_.logger
-Log_.set_super_log(logger.critical) # 控制superlog 打印的等级 默认是最高级单独存储一个文件
-super_log = Log_.super_log # 调试工具
-inference_save_case = False
 
 from .prompt_craft import AsyncIntel, Intel, IntelNew

pro_craft-0.2.58/src/pro_craft/code_helper/agent.py

@@ -0,0 +1,90 @@
+# LLM1
+
+import os
+from typing import Literal
+# from tavily import TavilyClient
+from deepagents import create_deep_agent
+from .tools import search_template_by_text, get_template_details, ask_user_for_clarification, generate_request_file
+
+
+# System prompt to steer the agent to be an expert researcher
+research_instructions = """你是一个高级代码生成助手 Agent，你的主要职责是帮助用户通过模板快速生成代码。
+
+**你的目标是：**
+1.  **精确理解用户对代码功能和结构的自然语言描述。**
+2.  **在现有模板库中，智能地找到最符合用户需求的模板。**
+3.  **如果找不到高匹配度的模板，引导用户创建新模板。**
+4.  **基于选定的模板和用户需求，生成一个结构化、可执行的 `REQUEST_START/END` 指令文件，用于后续的代码生成。**
+5.  **在必要时与用户进行交互，澄清需求或提供建议。**
+
+**你的可用工具:**
+
+1.  **`search_template_by_text(query: str, top_k: int = 5) -> List[Dict[str, Any]]`**
+    *   **描述:** 根据自然语言查询在模板库中进行语义搜索（使用 Qdrant 向量检索），返回最相关的 `top_k` 个模板的摘要信息。
+    *   **返回字段示例:** `[{'template_id': 'uuid', 'template_name': 'str', 'description': 'str', 'match_score': 'float'}]`
+    *   **何时使用:** 当你需要根据用户需求找到合适的代码模板时。
+
+2.  **`get_template_details(template_id: str) -> Dict[str, Any]`**
+    *   **描述:** 根据 `template_id` 从数据库中获取模板的完整详细信息，包括模板代码、推断出的命名约定和使用建议。
+    *   **返回字段示例:** `{'template_id': 'uuid', 'template_name': 'str', 'template_code': 'str', 'suggested_naming_conventions': 'json', 'usage_guidance': 'str'}`
+    *   **何时使用:** 当你已经选择了一个模板，需要其详细内容来生成指令时。
+
+3.  **`generate_request_file(template_code: str, user_request_details: Dict[str, Any], naming_conventions: Dict[str, Any]) -> str`**
+    *   **描述:** 根据选定的模板代码、解析后的用户需求（结构化形式）和模板的命名约定，生成符合 `REQUEST_START/END` 格式的指令文件。
+    *   **何时使用:** 当你已经确定了模板，并且充分理解了用户需求的所有细节，准备生成最终指令时。
+
+4.  **`ask_user_for_clarification(question: str) -> str`**
+    *   **描述:** 当你对用户需求有疑问，或需要用户做选择（例如在多个匹配模板中选择一个）时，使用此工具向用户提问。
+    *   **返回:** 用户的回答。
+    *   **何时使用:** 任何需要用户输入或确认的场景。
+
+**你的工作流程:**
+
+1.  **接收用户需求：** 用户会提供一个自然语言描述。
+2.  **初步理解与模板搜索：**
+    *   首先使用 `search_template_by_text` 工具，以用户需求的概要作为 `query`，找到 `top_k` 个最相关的模板。
+    *   分析搜索结果中的 `match_score` 和 `description`，评估匹配度。
+3.  **决策点 - 模板匹配：**
+    *   **高匹配度：** 如果存在一个或少数几个模板的 `match_score` 显著高，且 `description` 与用户需求高度吻合：
+        *   使用 `get_template_details` 获取该模板的完整信息。
+        *   进入 **需求细化与指令生成** 阶段。
+    *   **中等匹配度 / 多个相似匹配：** 如果有多个模板得分接近，或没有一个模板完美匹配：
+        *   使用 `ask_user_for_clarification` 工具，向用户展示这些模板的 `template_name` 和 `description`，并询问用户希望选择哪一个，或者是否希望在此基础上进行调整。
+        *   根据用户反馈，决定是选择一个模板还是引导用户创建新模板。
+    *   **低匹配度 / 无匹配：** 如果没有找到任何合适的模板（例如，所有 `match_score` 都很低）：
+        *   使用 `ask_user_for_clarification` 工具，告知用户未能找到合适的模板，并询问用户是否希望提供多个示例代码，以便使用 LLM 0 创建一个新的模板。
+        *   如果用户同意，引导用户进入 LLM 0 的流程。
+4.  **需求细化与指令生成 (基于选定模板):**
+    *   一旦确定了模板，仔细解析用户需求的每个细节，并将其映射到选定模板中的 `BLOCK` 和 `PLACEHOLDER`。
+    *   考虑模板的 `suggested_naming_conventions`，并尝试将其整合到生成的指令中。
+    *   如果用户需求与模板的某个 `BLOCK` 或 `PLACEHOLDER` 不兼容，或用户没有提供足够的细节来填充某个区域，使用 `ask_user_for_clarification` 向用户提问。
+    *   当所有必要信息都已获取且明确无误时，使用 `generate_request_file` 工具生成最终的 `REQUEST_START/END` 指令文件。
+5.  **输出最终指令：** 将 `generate_request_file` 的输出返回给系统，以便进行下一步的代码生成。
+
+**交互约束:**
+*   除非使用 `ask_user_for_clarification` 工具，否则不要直接与用户对话。
+*   始终以使用工具作为首选行动。
+*   保持你的回复简洁、直接，聚焦于完成任务。
+
+**示例用户需求:**
+"我需要一个API来发送用户消息。路径是 `/send`，POST 方法。输入模型叫 `SendMessageRequest`，包含 `user_id` (UUID格式) 和 `message_content` (字符串，最大500字)。输出模型叫 `SendMessageResponse`，继承 `CommonResponseModel`，额外包含 `message_id`。它会调用 `message_service_manager.send_message(user_id, content)`。如果 `user_id` 无效，应该返回 400 错误。"
+"""
+from langchain.chat_models import init_chat_model
+
+model = init_chat_model(
+            model="openai:gemini-2.5-flash-preview-05-20-nothinking",
+            api_key=os.getenv("BIANXIE_API_KEY"),
+            base_url=os.getenv("BIANXIE_BASE"),
+        )
+
+agent = create_deep_agent(
+    model=model,   
+    tools=[search_template_by_text, get_template_details, ask_user_for_clarification, generate_request_file],
+    system_prompt=research_instructions
+)
+
+
+if __name__ == "__main__":
+    result = agent.invoke({"messages": [{"role": "user", "content": "hello"}]})
+
+    print(result["messages"][-1].content)

pro_craft-0.2.58/src/pro_craft/code_helper/codermanager.py

@@ -0,0 +1,143 @@
+
+from sqlalchemy import create_engine
+import os
+from typing import List
+from .database import Base, CodeTemplate
+from .vectorstore import VolcanoEmbedding
+QDRANT_COLLECTION_NAME = "template_collection" # 你的 Qdrant collection 名称
+from pro_craft.utils import create_session
+from qdrant_client import QdrantClient, models
+from uuid import uuid4
+from .template_extract import extract_template
+from qdrant_client import QdrantClient
+from qdrant_client.models import Filter, FieldCondition, MatchValue, PointStruct, CollectionStatus, Distance, VectorParams
+
+class CoderTemplateManager():
+    def __init__(self,
+                 database_url = "mysql+pymysql://zxf_root:Zhf4233613%40@rm-2ze0793c6548pxs028o.mysql.rds.aliyuncs.com:3306/serverz",
+                 model_name = "",
+                 logger = None,
+                ):
+        database_url = database_url or os.getenv("database_url")
+        assert database_url
+        self.engine = create_engine(database_url, echo=False, # echo=True 仍然会打印所有执行的 SQL 语句
+                                    pool_size=10,        # 连接池中保持的连接数
+                                    max_overflow=20,     # 当pool_size不够时，允许临时创建的额外连接数
+                                    pool_recycle=3600,   # 每小时回收一次连接
+                                    pool_pre_ping=True,  # 使用前检查连接活性
+                                    pool_timeout=30      # 等待连接池中连接的最长时间（秒）
+                                    ) 
+        self.embedding_model = VolcanoEmbedding(
+            model_name = "doubao-embedding-text-240715",
+            api_key = "39ad310a-c6f7-4d66-962e-1fbfa7e6edf1"
+        )
+
+
+        Base.metadata.create_all(self.engine)
+        
+        self.connection = QdrantClient(host="127.0.0.1", port=6333)
+
+        self.connection.recreate_collection(
+            collection_name=QDRANT_COLLECTION_NAME,
+            vectors_config=models.VectorParams(size=2560, distance=models.Distance.COSINE),
+        )
+        self.logger = logger
+    
+        # if model_name in ["gemini-2.5-flash-preview-05-20-nothinking",]:
+        #     self.llm = BianXieAdapter(model_name = model_name)
+        # elif model_name in ["doubao-1-5-pro-256k-250115","doubao-1-5-pro-32k-250115"]:
+        #     self.llm = ArkAdapter(model_name = model_name)
+        # else:
+        #     raise Exception("error llm name")
+
+    def get_embedding(self,text: str) -> List[float]:
+        return self.embedding_model._get_text_embedding(text)
+    
+    def add_template(self,
+                     use_case: str,
+                     template_id: str,
+                     description: str,):   
+        template = extract_template(use_case)
+        embedding_vector = self.get_embedding(description)
+        points = [
+                models.PointStruct(
+                    id = str(uuid4()),
+                    vector=embedding_vector,
+                    payload={
+                        "template_id": template_id,
+                        "description": description,
+                        "use_case": use_case,
+                        "template": template,
+                    }
+                )
+            ]
+        self.connection.upsert(
+            collection_name=QDRANT_COLLECTION_NAME,
+            wait=True,
+            points=points
+        )
+        # 数据库
+        with create_session(self.engine) as session:
+            new_template = CodeTemplate(
+                template_id=template_id,
+                version=1,
+                description=description,
+                template_code=template,
+            )
+            session.add(new_template)
+            session.commit()
+            session.refresh(new_template)
+        return "success"
+
+
+    def delete_template(self, template_id: str) -> bool:
+        """
+        逻辑删除指定的代码模板。
+        """
+
+
+        # 3. 使用属性删除点
+        # 目标：删除所有 'color' 属性为 'red' 的点
+
+        # 定义一个过滤器
+        # 这个过滤器会匹配所有 payload 中 'color' 字段值为 'red' 的点
+        _filter = Filter(
+            must=[
+                FieldCondition(
+                    key="template_id",
+                    match=MatchValue(value=template_id)
+                )
+            ]
+        )
+        self.connection.delete(
+            collection_name=QDRANT_COLLECTION_NAME,
+            points_selector=_filter,
+            wait=True
+        )
+
+
+        with create_session(self.engine) as session:
+            template = session.query(CodeTemplate).filter_by(template_id=template_id).first()
+            if template:
+                session.delete(template)
+                session.commit()
+                return True
+        return False
+    
+        
+    def search(self, text , limit , query_filter=None):
+        query_vector = self.get_embedding(text)
+        results = self.connection.search(
+            collection_name=QDRANT_COLLECTION_NAME,
+            query_vector=query_vector,
+            limit=limit,
+            query_filter=query_filter
+        )
+        return results
+
+    def get_template_obj(self, template_id: str):
+        # 模拟从数据库获取模板详情
+        # 实际使用时，你需要根据你的数据库 setup 来实现
+        with create_session(self.engine) as session:
+            template = session.query(CodeTemplate).filter_by(template_id = template_id).first()
+        return template

pro_craft-0.2.58/src/pro_craft/code_helper/database.py

@@ -0,0 +1,36 @@
+from sqlalchemy import Column, Integer, String, Text, DateTime, text, UniqueConstraint, Boolean, func, Float, Double
+from sqlalchemy.orm import declarative_base
+
+from datetime import datetime, timedelta
+
+FileBase = declarative_base()
+
+
+# template_id (PK)
+#  template_name (e.g., "FastAPI Router Endpoint")
+#  description (e.g., "FastAPI服务路由器中的单个API端点，包含Pydantic校验、异步调用、Try-Except错误处理和日志记录。")
+#  template_code (实际的模板代码字符串)
+#  suggested_naming_conventions (JSONB 或文本)
+#  usage_guidance (文本)
+#  language (e.g., "Python")
+#  framework (e.g., "FastAPI")
+#  version
+#  created_by
+#  created_at
+#  last_updated_at
+
+
+from sqlalchemy import Column, Integer, String, Text, DateTime, text, UniqueConstraint, Boolean, func, Float, Double
+from sqlalchemy.orm import declarative_base
+
+from datetime import datetime, timedelta
+
+Base = declarative_base()
+
+class CodeTemplate(Base):
+    __tablename__ = 'code_template'
+    template_id = Column(String(255), primary_key=True, nullable=False, comment="自增")
+    description = Column(Text, nullable=False, comment="Detailed description of the template")
+    template_code = Column(Text, nullable=False, comment="The actual code of the template")
+    version = Column(Integer, nullable=True, comment="Template version")
+    # UniqueConstraint('template_name', name='uq_template_name') # 如果 template_name 应该是唯一的

pro_craft-0.2.58/src/pro_craft/code_helper/paper_program.py

@@ -0,0 +1,183 @@
+from pro_craft import Intel
+from pro_craft.log import Log
+from pro_craft.utils import extract_
+from typing import List, Dict, Any
+from llmada.core import BianXieAdapter
+import re
+import json
+
+logger = Log.logger
+
+intel = Intel(model_name="doubao-1-5-pro-256k-250115")
+
+class CoderHelper():
+    def __init__(self):
+        self.bx = BianXieAdapter()
+
+
+    @intel.intellect_remove_warp(prompt_id ="代码修改-最小化改动001")
+    def minedit_prompt(self,input:dict):
+        # 可以做pydantic 的校验
+        input = extract_(input, pattern_key = r"python")
+        return input
+
+    @intel.intellect_remove_warp(prompt_id ="高定制化自由函数修改_001")
+    def free_function_prompt(self,input:dict,kwargs):
+        # 可以做pydantic 的校验
+        result_ = extract_(input, pattern_key = r"python")
+        if not result_:
+            return None
+        
+        complet_code = result_ + "\n" + f'result = Function(**{kwargs})'
+            
+        rut = {"result": ""}
+        # 使用exec执行代码，并捕获可能的错误
+        try:
+            exec(
+                complet_code, globals(), rut
+            )  # 将globals()作为全局作用域，避免依赖外部locals()
+        except Exception as e:
+            logger.error(f"执行动态生成的代码时发生错误: {e}")
+            return None  # 返回None或抛出异常
+
+        return rut.get("result")
+    
+    def min_edit(self,code:str, edit_demand:str):
+        input_ = {"源码":code,
+                "功能需求":edit_demand
+                }
+        data = self.minedit_prompt(input = input_)
+        return data
+    
+    def free_function(self,function: str ="帮我将 日期 2025/12/03 向前回退12天", 
+                      **kwargs):
+        # params = locals()
+        prompt_user_part = f"{function}"
+        if kwargs:
+            prompt_user_part += "入参 : \n"
+            prompt_user_part += json.dumps(kwargs,ensure_ascii=False)
+
+        exec_result = self.free_function_prompt(input = prompt_user_part,kwargs = kwargs)
+
+        return exec_result
+
+        
+    def free_function_advanced(self):
+        pass
+
+class Paper():
+    def __init__(self,content):
+        self.content = content
+
+    @intel.intellect_remove_warp(prompt_id ="白板编辑-修改画板001")
+    def system_prompt(self,data):
+        return data
+        
+    def talk(self,prompt:str):
+        data = {"data":self.content+ prompt}
+        result = self.system_prompt(data = data)
+        # result = bx.product(system_prompt+ self.content+ prompt)
+        print(result,'result')
+        result_json = json.loads(extract_(result,pattern_key = r"json"))
+        print(result_json,'result_json')
+        for ops in result_json:
+            self.deal(ops.get('type'), ops.get('operations'))
+            
+    
+    def deal(self, type_, operations:str):
+        if type_ == "add":
+            self.add(operations)
+        elif type_ == "delete":
+            self.delete(operations)
+        else:
+            print('error')
+
+    def add(self, operations:str):
+        print('add running')
+        match_tips = re.search(r'<mark>(.*?)</mark>', operations, re.DOTALL)
+        positon_ = operations.replace(f"<mark>{match_tips.group(1)}</mark>","")
+        # 锁定原文
+        positon_frist = operations.replace('<mark>',"").replace('</mark>',"")
+        print(positon_frist,'positon_frist')
+        print('==========')
+        print(positon_,'positon__')
+        self.content = self.content.replace(positon_,positon_frist)
+
+    def delete(self, operations:str):   
+        # 制定替换内容
+        print('delete running')
+        match_tips = re.search(r'<mark>(.*?)</mark>', operations, re.DOTALL)
+        positon_ = operations.replace(f"<mark>{match_tips.group(1)}</mark>","")
+        # 锁定原文
+        positon_frist = operations.replace('<mark>',"").replace('</mark>',"")
+        print(positon_frist,'positon_frist')
+        assert positon_frist in self.content
+        print('==========')
+        print(positon_,'positon__')
+        
+        self.content = self.content.replace(positon_frist,positon_)
+
+
+
+mermaid_format = """
+```mermaid
+{result}
+```"""
+
+class ProgramChart():
+    '''
+    # ## 有一个原始的程序框图, -> 可以通过需求来调整程序框图 -> 结合数据库来调度程序框图
+    # 一个新的任务, => 基本需求, -> 根据需求调取之前的程序框图, -> 融合程序框图 -> 调整程序框图到完成满意,-> 由程序框图实现代码, 并拉取出待实现函数
+    # -> 用知识库中获取代码与对应的测试, 整合到待实现函数中, -> 剩余的使用封装好的包进行补充, -> 创新的补充, -> ...
+
+
+    inputs = """
+    帮我实现一个文件读取的逻辑
+    """
+    program_chart = init_program_chart_mermaid(inputs) # TODO 类图另做吧
+    # 一直循环, 直到满意
+    program_chart = finetune_program_chart(program_chart + "如果文件不存在, 就创建")
+    codes = fill_code_frame_program_chart(program_chart) #TODO 可以尝试配置对应的pytest
+
+    '''
+
+    # TODO 数据用例等, 只是保存, 真正做统计的时候可以导出选择合适的数据
+
+    @intel.intellect_remove_warp(prompt_id="程序框图-根据需求创建")
+    def init_program_chart_mermaid(self,input_data:str,
+                                   output_format:str):
+        result = extract_(input_data,r"mermaid")
+        input_ = mermaid_format.format(result = result)
+
+        with open("/Users/zhaoxuefeng/GitHub/obsidian/工作/TODO/1根据需求创建.md",'w') as f:
+            f.write(input_)
+        return input_
+
+    @intel.intellect_remove_warp(prompt_id="程序框图-白板微调")
+    def finetune_program_chart(self,input_data:str,
+                                   output_format:str):
+        print(input_data,'input_datainput_datainput_data')
+        result = extract_(input_data,r"mermaid")
+        input_ = mermaid_format.format(result = result)
+        with open("/Users/zhaoxuefeng/GitHub/obsidian/工作/TODO/1根据需求创建.md",'w') as f:
+            f.write(input_)
+        return input_
+
+    @intel.intellect_remove_warp(prompt_id="程序框图-框架实现")
+    def fill_code_frame_program_chart(self,input:dict):
+        # result = extract_(input.get("program_chart"),r"python")
+        code = input.get("program_chart")
+
+        with open("/Users/zhaoxuefeng/GitHub/obsidian/工作/TODO/3框架实现.md",'w') as f:
+            f.write(code)
+        return code
+
+    def pc_work(self,chat,fill = False):
+        self.init_program_chart_mermaid(chat)
+
+        program_chart = self.finetune_program_chart
+
+        code = self.fill_code_frame_program_chart(input = {
+            "program_chart":program_chart
+        })
+

pro_craft-0.2.58/src/pro_craft/code_helper/template_extract.py

@@ -0,0 +1,134 @@
+LLM0 = """
+
+你是一个高级代码分析和模板工程师AI。你的任务是根据用户提供的多个编程示例和场景描述，提炼出一个高质量、通用且符合约定格式的代码模板。
+
+**输入格式:**
+用户将以以下结构向你提供信息：
+
+--- SCENARIO_DESCRIPTION_START ---
+[用户提供的场景描述]
+--- SCENARIO_DESCRIPTION_END ---
+
+--- CODE_EXAMPLE_START: [文件名1] ---
+[第一个示例代码内容]
+--- CODE_EXAMPLE_END: [文件名1] ---
+
+--- CODE_EXAMPLE_START: [文件名2] ---
+[第二个示例代码内容]
+--- CODE_EXAMPLE_END: [文件名2] ---
+...
+[用户可能提供3到5个或更多示例]
+...
+--- CODE_EXAMPLE_START: [文件名N] ---
+[第N个示例代码内容]
+--- CODE_EXAMPLE_END: [文件名N] ---
+
+**你的任务和提炼原则:**
+
+1.  **理解场景：** 仔细阅读 SCENARIO_DESCRIPTION，理解所有示例代码的共同目的和核心业务逻辑。
+2.  **分析共性：**
+    *   识别所有示例中重复出现或结构上高度相似的代码段（例如：导入语句、类/函数定义、错误处理结构、Pydantic模型定义模式）。这些构成模板的**固定部分**。
+    *   识别在所有示例中都出现，但内容可能有所差异的通用常量、变量名、类名、函数名或方法名。这些是潜在的**命名约定**。
+3.  **识别差异和可变性：**
+    *   找出在不同示例中有所不同、需要根据具体需求调整的部分（例如：API路径、Pydantic模型的具体字段、业务逻辑调用的函数名及其参数、错误处理中的特定异常类型、日志消息内容）。这些构成模板的**可变部分**。
+4.  **生成模板代码：**
+    *   使用提供的示例代码中最具代表性的一个作为基础，或者综合多个示例的特点来构建模板。
+    *   **固定部分：** 直接保留在模板中，不加特殊标记。
+    *   **可变部分：** 使用我们约定的标记进行替换或封装：
+        *   **`<!-- BLOCK_START: [块名称] -->` / `<!-- BLOCK_END: [块名称] -->`：** 用于封装较大的、多行的可变代码逻辑块（例如Pydantic模型定义块、API端点实现块）。在 `BLOCK_START` 之后紧跟一行注释 `AI: [该块的预期用途和示例]`。
+        *   **`<!-- PLACEHOLDER: [占位符名称] -->` / `<!-- END_PLACEHOLDER: [占位符名称] -->`：** 用于封装较小的、行内或短代码片段的可变内容（例如特定导入、单个配置项、特定函数参数）。在 `PLACEHOLDER` 之后紧跟一行注释 `AI: [该占位符的预期用途和示例]`。
+        *   如果某个小块的代码在示例中是固定的，但你判断它未来很可能会根据用户需求变化，也可以将其封装为 `PLACEHOLDER` 或 `BLOCK`。
+    *   **注释编写：** 为每个 `BLOCK` 和 `PLACEHOLDER` 添加清晰、简洁的注释，解释该区域的用途和预期的输入类型/内容。这些注释应直接跟在 `BLOCK_START` 或 `PLACEHOLDER` 标记之后。
+    *   **Docstrings/常规注释：** 保留示例代码中原有的 Docstrings 和常规注释，除非它们是示例特有的、不具通用性的。
+5.  **推断命名约定：**
+    *   根据示例代码中的命名模式（例如类名前缀、变量名风格、通用服务/管理器名称），推断并列出建议的命名约定。
+    *   这些命名约定应以我们约定的格式呈现。
+6.  **撰写模板使用建议：**
+    *   提供简要的文本说明，总结该模板最适合解决哪类问题，以及用户在使用时应重点关注哪些 `BLOCK` 或 `PLACEHOLDER`。
+
+**输出格式 (严格遵守):**
+
+你的输出必须包含以下三个部分，每个部分之间用 `---` 分隔：
+
+**第一部分：模板代码**
+
+```
+# [文件名称，例如: template_service.py]
+
+[提炼出的模板代码，包含 BLOCK_START/END 和 PLACEHOLDER/END_PLACEHOLDER 标记，以及必要的注释]
+```
+
+**第二部分：推断出的命名约定**
+
+```
+--- NAMING_CONVENTIONS_START ---
+**命名约定:**
+*   [推断出的命名约定1]
+*   [推断出的命名约定2]
+...
+--- NAMING_CONVENTIONS_END ---
+```
+
+**第三部分：模板使用建议**
+
+```
+--- USAGE_SUGGESTIONS_START ---
+**模板使用建议:**
+[简要说明该模板的适用场景和使用重点]
+--- USAGE_SUGGESTIONS_END ---
+```
+
+**重要提示:**
+*   请务必保持输出格式的完整性和准确性，尤其是各种标记的匹配。
+*   力求模板的通用性，同时通过详细的注释指导未来的使用。
+*   如果示例代码中有非常具体且不具通用性的部分，即使它重复出现，也要考虑是否将其作为可变部分处理。
+
+现在，请等待用户提供多个代码示例和场景描述。
+
+"""
+
+
+## 用户输入格式示例
+'''
+--- SCENARIO_DESCRIPTION_START ---
+这是一个Python脚本系列，它们都用于处理用户数据。
+基本流程是：从某个地方（文件、API等）加载原始用户数据，
+对数据进行清洗和标准化（例如，去除重复项，格式化地址），
+然后将处理后的数据保存到另一个位置（文件、数据库）。
+目标是提炼一个通用模板，以便后续可以快速生成处理不同数据源和目标的代码。
+--- SCENARIO_DESCRIPTION_END ---
+
+--- CODE_EXAMPLE_START: example1.py ---
+# 第一个示例代码内容
+# ...
+--- CODE_EXAMPLE_END: example1.py ---
+
+--- CODE_EXAMPLE_START: example2.py ---
+# 第二个示例代码内容
+# ...
+--- CODE_EXAMPLE_END: example2.py ---
+
+--- CODE_EXAMPLE_START: example3.py ---
+# 第三个示例代码内容
+# ...
+--- CODE_EXAMPLE_END: example3.py ---
+
+--- CODE_EXAMPLE_START: example4.py ---
+# 第四个示例代码内容
+# ...
+--- CODE_EXAMPLE_END: example4.py ---
+
+--- CODE_EXAMPLE_START: example5.py ---
+# 第五个示例代码内容
+# ...
+--- CODE_EXAMPLE_END: example5.py ---'''
+
+
+from modusched.core import BianXieAdapter
+
+def extract_template(User_Input):
+    """
+    """
+    bx = BianXieAdapter()
+    result = bx.product(LLM0 + User_Input)
+    return result