pro-craft 0.1.56__py3-none-any.whl → 0.2.58__py3-none-any.whl

pro_craft/code_helper/tools.py

@@ -0,0 +1,113 @@
+from .codermanager import CoderTemplateManager
+from typing import List, Dict, Any,Optional
+import re
+
+coder = CoderTemplateManager()
+
+# --- 工具函数实现 ---
+
+def search_template_by_text(query: str, top_k: int = 5) -> List[Dict[str, Any]]:
+    """
+    根据自然语言查询在模板库中进行语义搜索（使用 Qdrant 向量检索），返回最相关的 `top_k` 个模板的摘要信息。
+    """
+    print(f"input & {type(query)} & query: {query} top:k {top_k} ")
+    search_result = coder.search(
+        text=query,
+        limit=top_k,
+        # query_filter=None # 可以在这里添加额外的过滤条件，例如根据语言、框架过滤
+    )
+
+    templates_summary = []
+    for hit in search_result:
+        # 在实际 Qdrant 中，hit.id 是模板的ID，hit.payload 包含其他元数据
+        # 假设你的 Qdrant payload 中存储了 template_name 和 description
+        templates_summary.append({
+            'template_id': hit.payload.get("template_id"),
+            'description': hit.payload.get('description', 'No description provided.'),
+            'match_score': hit.score
+        })
+    print(f"output & {type(templates_summary)} & {templates_summary} ")
+    return templates_summary
+
+def get_template_details(template_id: str) -> Optional[Dict[str, Any]]: # template_id 根据你的模型是 Integer
+    """
+    根据 `template_id` 从数据库中获取模板的完整详细信息，包括模板代码、推断出的命名约定和使用建议。
+    """
+    print(f"input & {type(template_id)} & query: {template_id} ")
+    template = coder.get_template_obj(template_id = template_id)
+    if template:
+        return {
+            'template_id': template.template_id,
+            'description': template.description,
+            'template_code': template.template_code,
+            'version': template.version,
+        }
+    print(f"output & {type(template)} & {template} ")
+    return None
+
+
+def ask_user_for_clarification(question: str) -> str:
+    """
+    当你对用户需求有疑问，或需要用户做选择（例如在多个匹配模板中选择一个）时，使用此工具向用户提问。
+    """
+    print(f"input & {type(question)} & query: {question} ")
+    print("\n--- Agent 需要你的帮助 ---")
+    print(f"Agent: {question}")
+    user_input = input("你的回答: ")
+    print("-------------------------\n")
+    print(f"output & {type(user_input)} & query: {user_input} ")
+    return user_input
+
+
+def generate_request_file(template_code: str, user_request_details: Dict[str, Any], naming_conventions: Optional[Dict[str, Any]] = None) -> str:
+    """
+    根据选定的模板代码、解析后的用户需求（结构化形式）和模板的命名约定，生成符合 `REQUEST_START/END` 格式的指令文件。
+    `user_request_details` 应该是一个字典，键是 BLOCK/PLACEHOLDER 的名称，值是包含 '指令' 和 '约束/示例' 的字典。
+    """
+    print(f"input & {type(template_code)} & template_code: {template_code} user_request_details: {user_request_details} naming_conventions: {naming_conventions}")
+
+    request_parts = []
+
+    request_parts.append("--- REQUEST_START ---")
+    request_parts.append("template.py # 目标文件通常是这个，可以根据实际情况调整") # 假设一个通用文件名
+
+    # 添加整体目标描述
+    overall_goal = user_request_details.get("overall_goal", "完善代码模板以满足以下需求。")
+    request_parts.append(f"\n**目标：** {overall_goal}\n")
+
+    # 添加命名约定 (如果提供了)
+    if naming_conventions:
+        request_parts.append("**命名约定:**")
+        for key, value in naming_conventions.items():
+            request_parts.append(f"*   **{key}:** {value}")
+        request_parts.append("") # 空行
+
+    request_parts.append("**具体修改点：**\n")
+
+    # 遍历模板代码，找到所有的 BLOCK 和 PLACEHOLDER
+    # 然后根据 user_request_details 填充指令
+    # 这是一个简化版本，实际可能需要更复杂的解析器来处理嵌套块或动态生成的块
+    # 对于 MVP，我们可以假设 user_request_details 中包含了所有需要填充的块/占位符
+    block_pattern = r"(BLOCK_START|PLACEHOLDER):\s*(\w+)"
+    for match in re.finditer(block_pattern, template_code):
+        block_type = match.group(1)
+        block_name = match.group(2)
+
+        if block_name in user_request_details:
+            details = user_request_details[block_name]
+            instruction = details.get("指令", "")
+            constraint_example = details.get("约束/示例", "")
+
+            request_parts.append(f"*   **{block_type}: {block_name}**")
+            request_parts.append(f"    *   **指令：** {instruction}")
+            if constraint_example:
+                # 确保多行约束/示例能正确缩进
+                formatted_ce = "\n".join([f"    *   **约束/示例：** {line}" if i == 0 else f"    *   {line}" for i, line in enumerate(str(constraint_example).splitlines())])
+                request_parts.append(formatted_ce)
+            request_parts.append("") # 空行
+
+    request_parts.append("--- REQUEST_END ---")
+    print(f"output & {type(request_parts)} & request_parts: {request_parts} ")
+
+    return "\n".join(request_parts)
+

pro_craft/code_helper/vectorstore.py

@@ -0,0 +1,81 @@
+# --- 假设的依赖项 ---
+# Qdrant 客户端
+from qdrant_client import QdrantClient, models # 你需要根据实际情况导入 Qdrant 客户端
+qdrant_client = QdrantClient(host="localhost", port=6333) # 示例Qdrant客户端初始化
+
+
+from typing import Any, List
+from llama_index.core.bridge.pydantic import PrivateAttr
+from llama_index.core.embeddings import BaseEmbedding
+from volcenginesdkarkruntime import Ark
+
+
+class VolcanoEmbedding(BaseEmbedding):
+    _model = PrivateAttr()
+    _ark_client = PrivateAttr()
+    _encoding_format = PrivateAttr()
+
+    def __init__(
+        self,
+        model_name: str = "doubao-embedding-text-240715",
+        api_key: str = "",
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._ark_client = Ark(api_key=api_key)
+        self._model = model_name
+        self._encoding_format = "float"
+
+    @classmethod
+    def class_name(cls) -> str:
+        return "ark"
+
+    def _get_query_embedding(self, query: str) -> List[float]:
+        """
+        获取查询字符串的 embedding。
+        通常查询和文档使用相同的 embedding 模型。
+        """
+
+        resp = self._ark_client.embeddings.create(
+            model=self._model,
+            input=[query],
+            encoding_format=self._encoding_format,
+        )
+        return resp.data[0].embedding
+
+    def _get_text_embedding(self, text: str) -> List[float]:
+        """
+        获取单个文档字符串的 embedding。
+        """
+        resp = self._ark_client.embeddings.create(
+            model=self._model,
+            input=[text],
+            encoding_format=self._encoding_format,
+        )
+        return resp.data[0].embedding
+
+    def _get_text_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """
+        批量获取文档字符串的 embedding。
+        如果你的火山模型支持批量推理，强烈建议实现此方法以提高效率。
+        否则，它可以简单地循环调用 _get_text_embedding。
+        """
+        resp = self._ark_client.embeddings.create(
+            model=self._model,
+            input=texts,
+            encoding_format=self._encoding_format,
+        )
+        return [i.embedding for i in resp.data]
+
+    async def _aget_query_embedding(self, query: str) -> List[float]:
+        return self._get_query_embedding(query)
+
+    async def _aget_text_embedding(self, text: str) -> List[float]:
+        return self._get_text_embedding(text)
+
+if __name__ == "__main__":
+
+    embedding_model = VolcanoEmbedding(
+        model_name = "doubao-embedding-text-240715",
+        api_key = "39ad310a-c6f7-4d66-962e-1fbfa7e6edf1"
+    )

pro_craft/code_helper/write_code.py

@@ -0,0 +1,61 @@
+llm2 = """
+你是一个专业的Python代码修改和生成AI。你的任务是根据用户提供的代码模板文件和详细的修改指令文件，精确地对模板进行补充、完善和修改。
+
+**你的目标是：**
+1.  **严格遵循指令文件中的所有要求，尤其是针对特定 `BLOCK` 和 `PLACEHOLDER` 的指令和约束/示例。**
+2.  **尽可能应用指令文件中提供的命名约定。**
+3.  **仅修改指令明确要求修改的部分，模板中未被指令覆盖的固定部分必须保持不变。**
+4.  **最终输出完整且可运行的Python代码。**
+
+**输入格式:**
+用户将以以下两个部分向你提供信息：
+
+--- TEMPLATE_CODE_START ---
+[原始的代码模板内容，其中包含 BLOCK_START/END 和 PLACEHOLDER/END_PLACEHOLDER 标记]
+--- TEMPLATE_CODE_END ---
+
+--- REQUEST_FILE_START ---
+[一个结构化的指令文件，格式为 REQUEST_START/END，包含目标、命名约定和具体修改点]
+--- REQUEST_FILE_END ---
+
+**你的工作流程和生成原则:**
+
+1.  **解析指令文件：**
+    *   首先解析 `REQUEST_FILE_START` 中的所有内容，理解其 `目标`、`命名约定` 和 `具体修改点`。
+    *   将 `具体修改点` 中的每个 `BLOCK` 和 `PLACEHOLDER` 指令及其 `约束/示例` 映射到模板代码中的对应位置。
+2.  **处理模板代码：**
+    *   逐行读取 `TEMPLATE_CODE_START` 中的模板代码。
+    *   当遇到 `BLOCK_START` 或 `PLACEHOLDER` 标记时：
+        *   查找指令文件中对应 `块名称` 的修改指令。
+        *   **如果存在指令：**
+            *   删除 `BLOCK_START` 和 `BLOCK_END` (或 `PLACEHOLDER` 和 `END_PLACEHOLDER`) 及其内部的原始内容（包括 `AI:` 注释）。
+            *   用指令中提供的代码**替换**该区域。
+            *   在替换的代码块的开始和结束位置，添加特殊的标记 `// AI_MODIFIED_START` 和 `// AI_MODIFIED_END` (如果只是新增内容，可以使用 `// AI_ADDED_START` 和 `// AI_ADDED_END`)。
+            *   如果指令是要求删除某些内容，请用 `// AI_DELETED_LINE: [原始行内容]` 标记被删除的行。
+        *   **如果不存在指令：**
+            *   保留该 `BLOCK` 或 `PLACEHOLDER` 及其内部的原始内容（包括 `AI:` 注释和标记本身），不做任何改动。这允许模板中的可选部分在没有明确指令时保持原样。
+    *   当遇到非标记的普通代码行时，保持其不变。
+3.  **应用命名约定：**
+    *   在生成或修改代码时，优先应用 `REQUEST_FILE_START` 中提供的 `命名约定`。
+    *   **重要：** 命名约定只应影响由你**生成或修改**的代码部分（即 `AI_ADDED` 或 `AI_MODIFIED` 区域）。你不能随意修改模板中未被明确指令触及的固定代码部分的命名。
+4.  **生成中间输出：**
+    *   首先生成包含所有 `// AI_ADDED/MODIFIED/DELETED` 标记的完整代码。这有助于后续的自动化工具进行变更追踪和人工核查。
+5.  **生成最终输出：**
+    *   在生成中间输出后，进一步处理该代码，**移除所有 `// AI_ADDED/MODIFIED/DELETED` 类型的标记**。
+    *   移除所有模板中遗留的 `BLOCK_START/END` 和 `PLACEHOLDER/END_PLACEHOLDER` 标记。
+    *   保留所有的 Docstrings 和常规的代码注释。
+
+**你的输出必须是最终的、清理后的完整 Python 代码文件内容。**
+
+"""
+
+from modusched.core import BianXieAdapter
+bx = BianXieAdapter()
+from pro_craft.utils import extract_
+def write_code(request):
+    result = bx.product(llm2 + request)
+    print(result)
+    python_code = extract_(result,r"python")
+    with open("output.py","w",encoding="utf-8") as f:
+        f.write(python_code)
+    return "success" + " output.py generated."

pro_craft/database.py

@@ -1,5 +1,5 @@
 
-from sqlalchemy import Column, Integer, String, Text, DateTime, text, UniqueConstraint, Boolean, func, Float
+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
@@ -179,13 +179,10 @@ class Prompt(PromptBase):
 class UseCase(PromptBase):
     __tablename__ = 'ai_usecase' # 数据库中的表名，你可以改成你希望的名字
 
-    # __table_args__ = (
-    #     UniqueConstraint('prompt_id', 'use_case', name='_prompt_id_version_uc'),
-    #     # 'name' 参数是可选的，用于给数据库中的约束指定一个名称，方便管理和调试
-    # )
-
-    # id (int, primary_key=True, autoincrement=True)
-    # 你的属性表中 id 为 int, true (not null), true (primary key), 0 (length), ASC (key order), true (auto increment)
+    __table_args__ = (
+            UniqueConstraint('time',name='time_double_uc'),
+            # 'name' 参数是可选的，用于给数据库中的约束指定一个名称，方便管理和调试
+        )
     id = Column(
         Integer,
         primary_key=True,
@@ -196,19 +193,16 @@ class UseCase(PromptBase):
 
     # prompt_id (varchar 255, not null, unique)
     # 你的属性表中 prompt_id 为 varchar, 255 (length), true (not null)
-    prompt_id = Column(
+
+    level = Column(
         String(255),        # VARCHAR 类型，长度 255
         nullable=False,     # 不能为空    # 必须是唯一的，这会创建唯一索引
-        comment="Unique identifier for the prompt"
+        comment="level"
     )
-
-
-    # prompt (text, not null)
-    # 你的属性表中 prompt 为 text, true (not null)
-    use_case = Column(
-        Text,               # TEXT 类型，适用于长文本
-        nullable=False,     # 不能为空
-        comment="用例"
+    time = Column(
+        Double,
+        nullable=False,      # 不能为空
+        comment="时间戳"
     )
 
     timestamp = Column(
@@ -219,101 +213,47 @@ class UseCase(PromptBase):
         comment="时间戳"
     )
 
-    output = Column(
-        Text,               # TEXT 类型，适用于长文本
+    filepath = Column(
+        String(255),             # TEXT 类型，适用于长文本
         nullable=False,     # 不能为空
-        comment="AI输出"
+        comment="文件路径"
     )
 
-    # use_case (text, nullable)
-    # 你的属性表中 use_case 为 text, false (not null, 即 nullable=True), NULL (default value), '用例' (comment)
-    solution = Column(
-        Text,
-        nullable=True,      # 可以为空 (因为你的表格中 Not Null 为 false)
-        comment="理想结果"      # 列注释
-    )
 
-    faired_time = Column(
-        Integer,
+    function = Column(
+        String(255),             # TEXT 类型，适用于长文本
         nullable=False,     # 不能为空
-        comment="失败次数"
+        comment="函数"
     )
 
-    is_deleted = Column(Boolean, default=False, server_default=text('0')) 
-
-    # 定义 __repr__ 方法以便打印对象时有清晰的表示
-    def __repr__(self):
-        return (f"<Prompt(id={self.id}, prompt_id='{self.prompt_id}', "
-                f"use_case='{self.use_case[:50]}...', solution='{self.solution}')>"
-                f"is_deleted='{self.is_deleted}...'>")
-
-
-class EvalsInfo(PromptBase):
-    __tablename__ = 'ai_evals' # 数据库中的表名，你可以改成你希望的名字
-
-    # __table_args__ = (
-    #     UniqueConstraint('prompt_id', 'use_case', name='_prompt_id_version_uc'),
-    #     # 'name' 参数是可选的，用于给数据库中的约束指定一个名称，方便管理和调试
-    # )
-
-    # id (int, primary_key=True, autoincrement=True)
-    # 你的属性表中 id 为 int, true (not null), true (primary key), 0 (length), ASC (key order), true (auto increment)
-    id = Column(
-        Integer,
-        primary_key=True,
-        autoincrement=True, # 自动递增
+    lines = Column(
+        String(255),             # TEXT 类型，适用于长文本
         nullable=False,     # 不能为空
-        comment="Primary key ID"
-    )
-
-    # prompt_id (varchar 255, not null, unique)
-    # 你的属性表中 prompt_id 为 varchar, 255 (length), true (not null)
-    prompt_id = Column(
-        String(255),        # VARCHAR 类型，长度 255
-        nullable=False,     # 不能为空    # 必须是唯一的，这会创建唯一索引
-        comment="Unique identifier for the prompt"
-    )
-    status = Column(
-        String(255),        # VARCHAR 类型，长度 255
-        nullable=False,     # 不能为空    # 必须是唯一的，这会创建唯一索引
-        comment="通过/未通过"
+        comment="函数"
     )
-
-    score = Column(
-        Float,
+    target = Column(
+        Text,      # TEXT 类型，适用于长文本
         nullable=False,     # 不能为空
-        comment="失败次数"
+        comment="标签"
     )
 
-    total = Column(
-        Integer,
+    type_ = Column(
+        String(255),             # TEXT 类型，适用于长文本
         nullable=False,     # 不能为空
-        comment="失败次数"
+        comment="函数"
     )
 
-    # prompt (text, not null)
-    # 你的属性表中 prompt 为 text, true (not null)
-    bad_case = Column(
+    content = Column(
         Text,               # TEXT 类型，适用于长文本
         nullable=False,     # 不能为空
-        comment="用例"
-    )
-
-    timestamp = Column(
-        DateTime,
-        nullable=False,      # 不能为空
-        server_default=text('CURRENT_TIMESTAMP'),
-        onupdate=text('CURRENT_TIMESTAMP'),
-        comment="时间戳"
+        comment="The actual prompt text content"
     )
 
-
     is_deleted = Column(Boolean, default=False, server_default=text('0')) 
 
     # 定义 __repr__ 方法以便打印对象时有清晰的表示
     def __repr__(self):
         return (f"<Prompt(id={self.id}, prompt_id='{self.prompt_id}', "
-                f"status='{self.status}...', score='{self.score}')>"
-                f"total='{self.total}...', score='{self.score}')>"
+                f"use_case='{self.use_case[:50]}...', solution='{self.solution}')>"
                 f"is_deleted='{self.is_deleted}...'>")
 

pro_craft/log.py

@@ -1,7 +1,7 @@
 import logging
 import os
 from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
-
+import inspect
 class Log:
     _instance = None
     def __new__(cls, *args, **kwargs):
@@ -12,18 +12,18 @@ class Log:
     def __init__(self, console_level = logging.INFO, log_file_name="app.log"):
         self.Console_LOG_LEVEL = console_level
         self.log_file_name = log_file_name
-        os.makedirs("logs", exist_ok=True)
         self.LOG_FILE_PATH = os.path.join("logs", log_file_name)
+        os.makedirs(os.path.dirname(self.LOG_FILE_PATH), exist_ok=True)
         self.logger = self.get_logger()
-        self.super_log_level = self.logger.critical
 
     def get_logger(self):
         logger = logging.getLogger()
-        # logger.setLevel(self.LOG_LEVEL)
+        logger.setLevel(logging.DEBUG)
         if not logger.handlers:
             # --- 4. 配置 Formatter (格式化器) ---
+            # 以后有一个标准化的日志要使用logger 而非标的则使用super-log
             formatter = logging.Formatter(
-                "%(asctime)s - %(levelname)s - %(name)s - %(funcName)s - %(module)s:%(lineno)d - %(message)s"
+                "%(asctime)s $ %(created)f $ %(levelname)s $ %(funcName)s $ :%(lineno)d $ %(pathname)s $ %(message)s||"
             )
             # --- 5. 配置 Handler (处理器) ---
 
@@ -33,50 +33,80 @@ class Log:
             console_handler.setFormatter(formatter)
             logger.addHandler(console_handler)
 
-
-            # 文件
-
-            # 5.2 信息数据
-
-            # RotatingFileHandler: 按文件大小轮转
-            # maxBytes: 单个日志文件的最大字节数 (例如 10MB)
-            # backupCount: 保留的旧日志文件数量
-            file_handler = RotatingFileHandler(
+            # 文件系统
+            ## 主日志本
+            file_handler = RotatingFileHandler(  # RotatingFileHandler: 按文件大小轮转
                 self.LOG_FILE_PATH,
-                maxBytes=10 * 1024 * 1024,  # 10 MB
-                backupCount=5,
+                maxBytes=10 * 1024 * 1024,  # 10 MB # maxBytes: 单个日志文件的最大字节数 (例如 10MB)
+                backupCount=10, # backupCount: 保留的旧日志文件数量
                 encoding="utf-8",
             )
-            file_handler.setLevel(logging.INFO)  # 文件中显示所有指定级别的日志
+            file_handler.setLevel(logging.DEBUG)  # 文件中显示所有指定级别的日志
             file_handler.setFormatter(formatter)
             logger.addHandler(file_handler)
 
-            # 5.3 错误警告日志
+            ## 运行日志本
+            file_handler_info = RotatingFileHandler(
+                self.LOG_FILE_PATH.replace('.log','_info.log'),
+                maxBytes=10 * 1024 * 1024,  # 10 MB
+                backupCount=5,
+                encoding="utf-8",
+            )
+            file_handler_info.setLevel(logging.INFO)  # 文件中显示所有指定级别的日志
+            file_handler_info.setFormatter(formatter)
+            logger.addHandler(file_handler_info)
 
-            file_handler_debug = RotatingFileHandler(
+            ## 错误日志本
+            file_handler_warning = RotatingFileHandler(
                 self.LOG_FILE_PATH.replace('.log','_err.log'),
                 maxBytes=10 * 1024 * 1024,  # 10 MB
                 backupCount=5,
                 encoding="utf-8",
             )
-            file_handler_debug.setLevel(logging.WARNING)  # 文件中显示所有指定级别的日志
-            file_handler_debug.setFormatter(formatter)
+            file_handler_warning.setLevel(logging.WARNING)  # 文件中显示所有指定级别的日志
+            file_handler_warning.setFormatter(formatter)
+            logger.addHandler(file_handler_warning)
 
-            file_handler_cri = RotatingFileHandler(
-                self.LOG_FILE_PATH.replace('.log','_slog.log'),
+            ## 指定日志本 
+            file_handler_super = RotatingFileHandler(
+                self.LOG_FILE_PATH.replace('.log','_s.log'),
                 maxBytes=5 * 1024 * 1024,  # 10 MB
                 backupCount=5,
                 encoding="utf-8",
             )
-            file_handler_cri.setLevel(logging.CRITICAL)  # 文件中显示所有指定级别的日志
-            file_handler_cri.setFormatter(formatter)
-            logger.addHandler(file_handler_cri)
-        return logger
-    
-    def set_super_log(self,logger_info):
-        self.super_log_level = logger_info
+            file_handler_super.setLevel(logging.CRITICAL)  # 文件中显示所有指定级别的日志
+            file_handler_super.setFormatter(formatter)
+            logger.addHandler(file_handler_super)
+
+            # class ConfigFilter(logging.Filter):
+            #     # 初始化的方案
+            #     def __init__(self, config_value, name=''):
+            #         super().__init__(name)
+            #         self.config_value = config_value
 
-    def super_log(self,s, target: str = "target",logger = None):
-        logger = logger or self.super_log_level
-        logger("\n" + "=="*25 + target +"=="*25 +   f"\n   type:  {str(type(s))}" + f"\ncontent:  {s}")
+            #     def filter(self, record):
+            #         record.config_info = self.config_value # 添加到LogRecord
+            #         return True
 
+
+            # class CustomFilter(logging.Filter):
+            #     def filter(self, record):
+            #         # 添加自定义的用户ID
+            #         print(record,'recordrecordrecordrecordrecord')
+            #         record.user_id = os.getenv("CURRENT_USER_ID", "anonymous")
+            #         # 添加会话ID
+            #         # record.session_id = "SESSION_XYZ123" # 实际应用中可能从request或全局变量获取
+            #         frame = inspect.currentframe()
+            #         info = inspect.getframeinfo(frame)
+            #         # logger.error(f"Function name: {info.function} : {e}")
+            #         record.session_id = f"Function name: {info.function}"
+                    
+            #         return True # 必须返回True才能继续处理该日志记录
+
+            # # 将自定义过滤器添加到处理器或记录器
+            # logger.addFilter(CustomFilter())
+            # handler.addFilter(CustomFilter()) # 也可以加到handler上
+
+            logger.info("这是一个包含自定义信息的日志")
+        return logger
+