pro-craft 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

pro_craft/database.py

@@ -0,0 +1,233 @@
+
+from sqlalchemy import Column, Integer, String, Text, DateTime, text, UniqueConstraint, Boolean, func
+from sqlalchemy.orm import declarative_base
+
+from datetime import datetime, timedelta
+
+FileBase = declarative_base()
+
+class Content(FileBase):
+    __tablename__ = 'content' # 数据库中的表名，你可以改成你希望的名字
+
+    # 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, # 自动递增
+        nullable=False,     # 不能为空
+        comment="自增"
+    )
+
+    # prompt_id (varchar 255, not null, unique)
+    # 你的属性表中 prompt_id 为 varchar, 255 (length), true (not null)
+    embed_name_id = Column(
+        String(255),        # VARCHAR 类型，长度 255
+        nullable=False,     # 不能为空    # 必须是唯一的，这会创建唯一索引
+        comment="Unique identifier for the prompt"
+    )
+
+    # version (varchar 50, not null)
+    # 你的属性表中 version 为 varchar, 50 (length), true (not null)
+    name = Column(
+        String(255),         # VARCHAR 类型，长度 50
+        nullable=False,     # 不能为空
+        comment="Version of the prompt"
+    )
+
+    # version (varchar 50, not null)
+    # 你的属性表中 version 为 varchar, 50 (length), true (not null)
+    version = Column(
+        String(50),         # VARCHAR 类型，长度 50
+        nullable=False,     # 不能为空
+        comment="版本"
+    )
+    timestamp = Column(
+        DateTime,
+        nullable=False,      # 不能为空
+        server_default=text('CURRENT_TIMESTAMP'),
+        onupdate=text('CURRENT_TIMESTAMP'),
+        comment="时间戳"
+    )
+    content = Column(
+        Text,               # TEXT 类型，适用于长文本
+        nullable=False,     # 不能为空
+        comment="内容"
+    )
+    type = Column(
+        Integer,
+        nullable=True,      # 可以为空 (因为你的表格中 Not Null 为 false)
+        comment="类型"      # 列注释
+    )
+
+    # 定义 __repr__ 方法以便打印对象时有清晰的表示
+    def __repr__(self):
+        return (f"<Prompt(id={self.id}, prompt_id='{self.prompt_id}', "
+                f"version='{self.version}', timestamp='{self.timestamp}', "
+                f"prompt='{self.prompt[:50]}...', use_case='{self.use_case}')>")
+
+PromptBase = declarative_base()
+
+
+
+class SyncMetadata(PromptBase):
+    """用于存储同步元数据的表模型"""
+    __tablename__ = "sync_metadata"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    last_sync_time = Column(DateTime, default=datetime(1970, 1, 1))
+    table_name = Column(String(255), unique=True)
+
+    def __repr__(self):
+        return f"<SyncMetadata(table_name='{self.table_name}', last_sync_time='{self.last_sync_time}')>"
+
+
+class Prompt(PromptBase):
+    __tablename__ = 'prompts_table' # 数据库中的表名，你可以改成你希望的名字
+    # __tablename__ = 'llm_prompt' # 数据库中的表名，你可以改成你希望的名字
+
+    # 定义联合唯一约束
+    # 这是一个元组，包含你希望应用于表的额外定义，例如索引或约束
+    __table_args__ = (
+        UniqueConstraint('prompt_id', 'version', 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, # 自动递增
+        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"
+    )
+
+    # version (varchar 50, not null)
+    # 你的属性表中 version 为 varchar, 50 (length), true (not null)
+    version = Column(
+        String(50),         # VARCHAR 类型，长度 50
+        nullable=False,     # 不能为空
+        comment="Version of the prompt"
+    )
+
+    # timestamp (datetime, not null, default current_timestamp, on update current_timestamp)
+    # 你的属性表中 timestamp 为 datetime, true (not null), false (default value), true (generated always on update current_timestamp)
+    timestamp = Column(
+        DateTime,
+        nullable=False,      # 不能为空
+        # MySQL 的 DEFAULT CURRENT_TIMESTAMP
+        server_default=text('CURRENT_TIMESTAMP'),
+        # MySQL 的 ON UPDATE CURRENT_TIMESTAMP
+        onupdate=text('CURRENT_TIMESTAMP'),
+        comment="Timestamp of creation or last update"
+    )
+
+    # prompt (text, not null)
+    # 你的属性表中 prompt 为 text, true (not null)
+    prompt = Column(
+        Text,               # TEXT 类型，适用于长文本
+        nullable=False,     # 不能为空
+        comment="The actual prompt text content"
+    )
+
+    # use_case (text, nullable)
+    # 你的属性表中 use_case 为 text, false (not null, 即 nullable=True), NULL (default value), '用例' (comment)
+    use_case = Column(
+        Text,
+        nullable=True,      # 可以为空 (因为你的表格中 Not Null 为 false)
+        comment="用例"      # 列注释
+    )
+
+    # 执行类型
+    action_type = Column(
+        String(255),        # VARCHAR 类型，长度 255
+        nullable=False,     # 不能为空    # 必须是唯一的，这会创建唯一索引
+        comment="type train inference summary"
+    )
+
+    demand = Column(
+        Text,
+        nullable=True,      # 可以为空 (因为你的表格中 Not Null 为 false)
+        comment="提示词改动需求"      # 列注释
+    )
+
+    score = Column(
+        Integer,
+        nullable=False,     # 不能为空
+        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"version='{self.version}', timestamp='{self.timestamp}', "
+                f"prompt='{self.prompt[:50]}...', use_case='{self.use_case}')>"
+                f"action_type='{self.action_type}...', demand='{self.demand[:30]}')>"
+                f"is_deleted='{self.is_deleted}...'>"
+                )
+
+
+class UseCase(PromptBase):
+    __tablename__ = 'usecase' # 数据库中的表名，你可以改成你希望的名字
+
+    # 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, # 自动递增
+        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"
+    )
+
+
+    # prompt (text, not null)
+    # 你的属性表中 prompt 为 text, true (not null)
+    use_case = Column(
+        Text,               # TEXT 类型，适用于长文本
+        nullable=False,     # 不能为空
+        comment="用例"
+    )
+
+    output = Column(
+        Text,               # TEXT 类型，适用于长文本
+        nullable=False,     # 不能为空
+        comment="AI输出"
+    )
+
+    # 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="理想结果"      # 列注释
+    )
+
+    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}...'>")
+
+

pro_craft/designer.py

@@ -0,0 +1,115 @@
+
+
+
+## 分析编码习惯
+
+
+class MeetingMessageHistory:
+    def __init__(self):
+        self._messages: List[Dict[str, Any]] = []
+
+    def add_message(self, role: str, content: str, speaker_name: str = None):
+        """添加一条消息到历史记录。"""
+        message = {"role": role, "content": content}
+        if speaker_name:
+            message["speaker"] = speaker_name # 添加发言者元信息
+        self._messages.append(message)
+
+    def get_messages(self) -> List[Dict[str, Any]]:
+        """获取当前完整的消息历史。"""
+        return self._messages
+
+    def clear(self):
+        """清空消息历史。"""
+        self._messages = []
+
+    def __str__(self) -> str:
+         return "\n".join([f"[{msg.get('speaker', msg['role'])}] {msg['content']}" for msg in self._messages])
+    
+    
+# 模拟一个外部 LLM 调用函数，以便在框架中演示
+def simulate_external_llm_call(messages: List[Dict[str, Any]], model_name: str = "default") -> str:
+     """模拟调用外部 LLM 函数."""
+     print(messages[0].get('speaker'),'messages')
+     print(model_name,'model_name')
+
+     bx = BianXieAdapter()
+     bx.set_model(model_name)
+     result = bx.chat(messages)
+     simulated_response = f"[{model_name}] Responding to '{result}"
+     return simulated_response
+
+class MeetingOrganizer:
+    def __init__(self):
+        # 存储参会者信息：名称和使用的模型
+        self._participants: List[Dict[str, str]] = []
+        self._history = MeetingMessageHistory()
+        self._topic: str = ""
+        self._background: str = ""
+        # TODO: 在实际使用时，这里应该引用您真实的 LLM 调用函数
+        self._llm_caller = simulate_external_llm_call # 指向您外部的 LLM 调用函数
+
+    def set_llm_caller(self, caller_func):
+         """设置外部的 LLM 调用函数."""
+         self._llm_caller = caller_func
+         print("External LLM caller function set.")
+
+
+    def add_participant(self, name: str, model_name: str = "default"):
+        """添加一个参会者 (LLM) 到会议中。"""
+        participant_info = {"name": name, "model": model_name}
+        self._participants.append(participant_info)
+        print(f"Added participant: {name} (using model: {model_name})")
+
+    def set_topic(self, topic: str, background: str = ""):
+        """设置会议主题和背景。"""
+        self._topic = topic
+        self._background = background
+        initial_message = f"Meeting Topic: {topic}\nBackground: {background}"
+        # 可以将主题和背景作为用户输入的第一条消息，或者 system 消息
+        self._history.add_message("user", initial_message, speaker_name="Meeting Host")
+        print(f"Meeting topic set: {topic}")
+
+    def run_simple_round(self):
+        """执行一轮简单的会议：每个参会 LLM 基于当前历史回复一次。"""
+        if not self._participants:
+            print("No participants in the meeting.")
+            return
+
+        print("\n--- Running a Simple Meeting Round ---")
+        current_history = self._history.get_messages()
+
+        for participant in self._participants:
+            participant_name = participant["name"]
+            model_to_use = participant["model"]
+            try:
+                # 调用外部 LLM 函数
+                print(current_history,'current_history')
+                response_content = self._llm_caller(current_history, model_name=model_to_use)
+                # 将回复添加到历史中，并标记发言者
+                self._history.add_message("assistant", response_content, speaker_name=participant_name)
+                print(f"'{participant_name}' responded.")
+            except Exception as e:
+                print(f"Error during '{participant_name}' participation: {e}")
+                # 在框架阶段，简单的错误打印即可
+
+    def get_discussion_history(self) -> List[Dict[str, Any]]:
+        """获取完整的讨论消息历史。"""
+        return self._history.get_messages()
+
+    def get_simple_summary(self) -> str:
+        """获取简单的讨论摘要（第一阶段：拼接所有 LLM 发言）。"""
+        print("\n--- Generating Simple Summary ---")
+        summary_parts = []
+        for message in self._history.get_messages():
+            # 提取 assistant 角色的发言作为摘要内容
+            if message.get("role") == "assistant":
+                 speaker = message.get("speaker", "Unknown Assistant")
+                 summary_parts.append(f"[{speaker}]: {message['content']}")
+
+        return "\n\n".join(summary_parts)
+
+    def display_history(self):
+         """打印格式化的讨论历史。"""
+         print("\n--- Full Discussion History ---")
+         print(self._history)

pro_craft/evals.py

@@ -0,0 +1,68 @@
+
+import json
+
+from pro_craft.log import Log
+logger = Log.logger
+editing_log = logger.debug
+
+
+
+
+
+############evals##############
+
+ # 异步
+class Base_Evals():
+    def __init__(self):
+        """
+        # TODO 2 自动优化prompt 并提升稳定性, 并测试
+        通过重写继承来使用它
+        """
+        self.MIN_SUCCESS_RATE = 00.0 # 这里定义通过阈值, 高于该比例则通过
+
+
+    async def _assert_eval_function(self,params):
+        #这里定义函数的评价体系
+        print(params,'params')
+
+    async def get_success_rate(self,test_cases:list[tuple]):
+        """
+                # 这里定义数据
+
+        """
+
+        successful_assertions = 0
+        total_assertions = len(test_cases)
+        result_cases = []
+
+        for i, params in enumerate(test_cases):
+            try:
+                # 这里将参数传入
+                await self._assert_eval_function(params)
+                successful_assertions += 1
+                result_cases.append({"type":"Successful","--input--":params,"evaluate_info":f"满足要求"})
+            except AssertionError as e:
+                result_cases.append({"type":"FAILED","--input--":params,"evaluate_info":f"ERROR {e}"})
+            except Exception as e: # 捕获其他可能的错误
+                result_cases.append({"type":"FAILED","--input--":params,"evaluate_info":f"ERROR {e}"})
+
+
+        success_rate = (successful_assertions / total_assertions) * 100
+        print(f"\n--- Aggregated Results ---")
+        print(f"Total test cases: {total_assertions}")
+        print(f"Successful cases: {successful_assertions}")
+        print(f"Success Rate: {success_rate:.2f}%")
+
+        if success_rate >= self.MIN_SUCCESS_RATE:
+            return "通过", json.dumps(result_cases,ensure_ascii=False)
+        else:
+            return "未通过",json.dumps(result_cases,ensure_ascii=False)
+
+
+    def global_evals():
+        pass
+
+
+
+
+

pro_craft/file_manager.py

@@ -0,0 +1,118 @@
+# from db_help.mysql import MySQLManagerWithVersionControler
+from db_help.qdrant import QdrantManager
+from pydantic import BaseModel
+from datetime import datetime
+from pro_craft.utils import get_adler32_hash, embedding_inputs
+from pro_craft.prompt_helper import Intel, IntellectType
+from pro_craft.utils import extract_
+from enum import Enum
+import json
+
+from pro_craft.database import Base, Prompt
+from sqlalchemy import create_engine, Column, Integer, String
+from sqlalchemy.orm import sessionmaker, declarative_base
+from pro_craft.utils import create_session
+from pro_craft.database import Content
+
+import os
+intel = Intel(database_url = os.getenv("database_url"))
+        
+class TextType(Enum):
+    Code = 0
+    Prompt = 1
+    Tips = 2
+    Experience = 3
+
+class ContentManager():
+    def __init__(self):
+        """
+        """
+        self.table_name = "content"
+        self.qdrant = QdrantManager(host = "localhost")
+        self.neo = None
+
+    
+    @intel.intellect_2(IntellectType.inference,
+                    prompt_id = "db_help_001",
+                    demand="""
+name 后面加一个4位随机数字防止重复
+    """)
+    def diverter(self,input:dict):
+        # 根据需求修改程序框图
+        input = json.loads(extract_(input,pattern_key=r"json"))
+
+        class Output(BaseModel):
+            name : str
+            type : int
+            note : str
+
+        Output(**input)
+        return input
+
+
+    def save_content_auto(self,text:str):
+        
+        output = self.diverter(input = {"text":text})
+        print(output,'output')
+        self.save_content(text = text,
+                          name = output.get("name"),
+                          type = output.get("type"),
+                          )
+
+
+
+    def save_content(self,text:str,name:str,type:int | TextType)->str:
+        # 数据库维护版本, 而向量库只保持最新
+
+        # 1 存入到数据库中
+        embed_name_id = get_adler32_hash(name)
+
+        vector_list = embedding_inputs([text])
+        if isinstance(type,TextType):
+            type = type.value
+
+        with create_session(intel.engine) as session:
+            cont = Content(name = name,
+                    embed_name_id = embed_name_id,
+                    timestamp = datetime.now(),
+                    content = text,
+                    type = type,
+                    )
+            session.add(cont)
+            session.commit() # 提交事务，将数据写入数据库
+
+        # 2 存入到qdrant中
+        self.qdrant.update(self.table_name,
+                           data_list =[
+                               {
+                                "id":embed_name_id,
+                                "vector":vector_list[0],
+                                "payload":{
+                                    "name": name, 
+                                    'timestamp': datetime.now(),
+                                    "content": text,
+                                    "type":type}
+                                }
+                           ])
+        
+        
+        # 考虑使用知识图 + 增加因果联系
+
+    def save_to(self):
+        #TODO 尝试另存为
+        pass
+
+    def search(self,name:str,version = None):
+        with create_session(intel.engine) as session:
+            target_content = session.query(Content).filter_by(name = name,
+                                             version = version).frist()
+        result = target_content.content
+        return result
+    
+    def similarity(self,content: str,limit: int =2):
+        vector = embedding_inputs([content])[0]
+        result = self.qdrant.select_by_vector(query_vector = vector,
+                                collection_name = self.table_name,
+                                limit = limit)
+        return result
+