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

pro_craft/prompt_craft/async_.py

@@ -1,27 +1,22 @@
 # 测试1
 from pro_craft.utils import extract_
-from pro_craft import logger as pro_craft_logger
 from modusched.core import BianXieAdapter, ArkAdapter
-from datetime import datetime
 from enum import Enum
 import functools
 import json
 import os
-from pro_craft.database import Prompt, UseCase, PromptBase
+from pro_craft.database import Prompt, UseCase, PromptBase, SyncMetadata
 from pro_craft.utils import create_session, create_async_session
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine # 异步核心
 from sqlalchemy import select, delete # 导入 select, delete 用于异步操作
 import inspect
-from datetime import datetime
 from pro_craft.utils import extract_
 import asyncio
 import re
 from pydantic import BaseModel, ValidationError, field_validator
 from sqlalchemy import select, desc
 from json.decoder import JSONDecodeError
-from pro_craft.database import SyncMetadata
-from datetime import datetime, timedelta
-from datetime import datetime, timedelta
+
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
 from sqlalchemy import select, and_ # 引入 select 和 and_
 from sqlalchemy.orm import class_mapper # 用于检查对象是否是持久化的
@@ -31,6 +26,11 @@ from tqdm.asyncio import tqdm
 import pandas as pd
 import plotly.graph_objects as go
 
+def get_log_info(target: str, val = None):
+    return f"{target} & {type(val)} & {val}"
+
+
+
 BATCH_SIZE = int(os.getenv("DATABASE_SYNC_BATCH_SIZE",1000))
 
 def fix_broken_json_string(broken_json_str):
@@ -112,7 +112,7 @@ class AsyncIntel():
                  logger = None,
                 ):
         database_url = database_url or os.getenv("database_url")
-        self.logger = logger or pro_craft_logger
+        self.logger = logger
         try:
             assert database_url
             assert 'aio' in database_url
@@ -156,29 +156,6 @@ class AsyncIntel():
         async with engine.begin() as conn:
             await conn.run_sync(PromptBase.metadata.create_all)
 
-    async def get_prompt(self,prompt_id,version,session):
-        """
-        获取指定 prompt_id 的最新版本数据，通过创建时间判断。
-        """
-        if version:
-            stmt_ = select(Prompt).filter(
-                Prompt.prompt_id == prompt_id,
-                Prompt.version == version
-            )
-        else:  
-            stmt_ = select(Prompt).filter(
-                Prompt.prompt_id == prompt_id,
-            )
-        stmt = stmt_.order_by(
-                desc(Prompt.timestamp), # 使用 sqlalchemy.desc() 来指定降序
-                desc(Prompt.version)    # 使用 sqlalchemy.desc() 来指定降序
-            )
-
-        result = await session.execute(stmt)
-        result = result.scalars().first()
-
-        return result
-
     async def sync_production_database(self,database_url:str):
         target_engine = create_async_engine(database_url, echo=False)
         await self.create_database(target_engine) 
@@ -272,7 +249,29 @@ class AsyncIntel():
                 else:
                     print("No new records to sync.")
 
+    async def get_prompt(self,prompt_id,version,session):
+        """
+        获取指定 prompt_id 的最新版本数据，通过创建时间判断。
+        """
+        if version:
+            stmt_ = select(Prompt).filter(
+                Prompt.prompt_id == prompt_id,
+                Prompt.version == version
+            )
+        else:  
+            stmt_ = select(Prompt).filter(
+                Prompt.prompt_id == prompt_id,
+            )
+        stmt = stmt_.order_by(
+                desc(Prompt.timestamp), # 使用 sqlalchemy.desc() 来指定降序
+                desc(Prompt.version)    # 使用 sqlalchemy.desc() 来指定降序
+            )
 
+        result = await session.execute(stmt)
+        result = result.scalars().first()
+
+        return result
+    
     async def get_prompt_safe(self,
                              prompt_id: str,
                              version = None,
@@ -283,11 +282,13 @@ class AsyncIntel():
         prompt_obj = await self.get_prompt(prompt_id=prompt_id,version=version,session=session)
         if prompt_obj:
             return prompt_obj
+        if version:
+            prompt_obj = await self.get_prompt(prompt_id=prompt_id,version=None,session=session)
 
-        prompt_obj = await self.get_prompt(prompt_id=prompt_id,version=None,session=session)
+        if prompt_obj is None:
+            raise IntellectRemoveError("不存在的prompt_id")
         return prompt_obj
 
-        
     async def save_prompt(self,
                            prompt_id: str,
                            new_prompt: str,
@@ -328,375 +329,16 @@ class AsyncIntel():
         session.add(prompt1)
         await session.commit() # 提交事务，将数据写入数据库
 
-    async def get_use_case(self,
-                             target_prompt_id: str,
-                             start_time: datetime = None,  # 新增：开始时间
-                             end_time: datetime = None,    # 新增：结束时间
-                             session = None
-                            ):
-        """
-        从sql保存提示词
-        """
-        stmt = select(UseCase).filter(UseCase.is_deleted == 0,
-                                      UseCase.prompt_id == target_prompt_id)
-        
-        if start_time:
-            stmt = stmt.filter(UseCase.created_at >= start_time)  # 假设你的UseCase模型有一个created_at字段
-
-        if end_time:
-            stmt = stmt.filter(UseCase.created_at <= end_time)
-        result = await session.execute(stmt)
-        # use_case = result.scalars().one_or_none()
-        use_case = result.scalars().all()
-        return use_case
-
-    async def save_use_case2(self,session = None):
-        with open("/Users/zhaoxuefeng/GitHub/digital_life/logs/app.log",'r') as f:
-            x = f.read()
-
-        def work(resu):
-            if len(resu) == 9:
-                unix_timestamp_str = resu[2]
-                dt_object = datetime.datetime.fromtimestamp(float(unix_timestamp_str.strip()))
-                use_case = UseCase(
-                    time = resu[2],
-                    level = resu[1],
-                    timestamp =dt_object.strftime('%Y-%m-%d %H:%M:%S.%f'),
-                    filepath=resu[3],
-                    function=resu[4],
-                    lines=resu[5],
-                    type_=resu[6],
-                    target=resu[7],
-                    content=resu[8],
-                )
-                session.add(use_case)
-            else:
-                print(len(resu))
-                print(resu,'resu')
-
-
-        for res in x.split("||"):
-            resu = res.split("$")
-            work(resu)
-
-        await session.commit() # 提交事务，将数据写入数据库
-
-
-    async def save_use_case3(self, session):
-        log_filepath = "/Users/zhaoxuefeng/GitHub/digital_life/logs/app.log"
-
-        # 1. 获取数据库中已有的最新时间戳
-        # 假设 timestamp 列是 DATETIME 类型，且是用于唯一标识和排序的关键字段
-        latest_db_timestamp = None
-        try:
-            result = await session.execute(
-                select(UseCase.timestamp)
-                .order_by(UseCase.timestamp.desc())
-                .limit(1)
-            )
-            latest_db_timestamp = result.scalar_one_or_none()
-            if latest_db_timestamp:
-                print(f"Latest timestamp in DB: {latest_db_timestamp}")
-            else:
-                print("No records found in DB. Starting fresh.")
-        except Exception as e:
-            print(f"Error querying latest timestamp: {e}")
-            # 如果查询失败，可以选择继续，但可能导致重复导入，或者直接退出
-            return
-
-        added_count = 0
-        skipped_count = 0
-        error_count = 0
-
-        # 2. 读取并处理日志文件
-        try:
-            with open(log_filepath, 'r') as f:
-                x = f.read()
-        except FileNotFoundError:
-            print(f"Error: Log file not found at {log_filepath}")
-            return
-
-        # 日志记录通常是逐行添加的，所以倒序处理可能更高效，但也取决于文件大小和格式
-        # 对于你当前的分隔符格式，还是顺序处理比较直接
-        for res_str in x.split("||"):
-            if not res_str.strip(): # 跳过空字符串
-                continue
-
-            # 使用 try-except 块来处理可能的解析错误
-            try:
-                resu = res_str.split("$")
-                # 检查字段数量是否正确
-                # 你的原始代码期望 len(resu) == 9, 但是 SQL 语句有 10 个字段，
-                # UseCase 构造函数也有 9 个参数，这需要对应起来
-                # level, time, timestamp, filepath, function, lines, type_, target, content, is_deleted
-                # 对应 resu 的 index:   [1], [2],   [2],        [3],        [4],        [5],    [6],   [7],    [8]
-                # 看起来 resu[0] 是空的或者不用的，所以 resu 至少需要有 9 个元素（索引0-8）
-                # 因此，判断 len(resu) >= 9 即可
-                if len(resu) < 9:
-                    print(f"Skipping malformed log entry (not enough fields): {res_str}")
-                    error_count += 1
-                    continue
-
-                # 提取并清理原始数据
-                level_raw = resu[0].strip() # 假设 resu[0] 是 level
-                time_raw = resu[1].strip()  # 假设 resu[1] 是 time (原始日志时间字符串)
-                timestamp_raw = resu[2].strip() # 假设 resu[2] 是 timestamp (unix时间戳字符串)
-                filepath_raw = resu[3].strip()
-                function_raw = resu[4].strip()
-                lines_raw = resu[5].strip()
-                type_raw = resu[6].strip()
-                target_raw = resu[7].strip()
-                content_raw = resu[8].strip()
-
-                # 处理 time 字段 (原始日志时间字符串)
-                # 上次错误是 time 列太短，并且有换行符。在这里清理一下。
-                # 假设 time 字段就是你日志中 YYYY-MM-DD HH:MM:SS,ms 这种格式，
-                # 但你上次给的示例是 '\n2025-11-01 11:17:52,029 '，所以需要清理
-                processed_time_str = time_raw.replace('\n', '').strip()
-                # 如果数据库 time 列是 VARCHAR，确保长度够用
-                # 如果是 DATETIME，你需要解析它
-                # 例如：
-                # try:
-                #     dt_obj_from_time = datetime.datetime.strptime(processed_time_str, '%Y-%m-%d %H:%M:%S,%f')
-                #     # 再次格式化，确保数据库兼容
-                #     processed_time_str = dt_obj_from_time.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
-                # except ValueError:
-                #     print(f"Warning: Could not parse 'time' string: {processed_time_str}. Using raw string.")
-                #     # 或者跳过此条记录，或者设置为 None
-
-                # 处理 timestamp 字段 (Unix时间戳转换为 datetime 对象)
-                try:
-                    unix_timestamp_float = float(timestamp_raw)
-                    dt_object = datetime.datetime.fromtimestamp(unix_timestamp_float)
-                    # 格式化为 MySQL DATETIME(6) 兼容的字符串（包含微秒）
-                    formatted_timestamp = dt_object.strftime('%Y-%m-%d %H:%M:%S.%f')
-                except ValueError:
-                    print(f"Skipping malformed log entry (invalid timestamp float): {res_str}")
-                    error_count += 1
-                    continue
-
-                # 3. 比较时间戳进行增量检查
-                # 将格式化后的时间戳字符串转换为 datetime 对象进行比较
-                current_log_timestamp = datetime.datetime.strptime(formatted_timestamp, '%Y-%m-%d %H:%M:%S.%f')
-
-                if latest_db_timestamp and current_log_timestamp <= latest_db_timestamp:
-                    # print(f"Skipping existing log entry (timestamp: {current_log_timestamp})")
-                    skipped_count += 1
-                    continue # 跳过已存在的或旧的记录
-
-                # 创建 UseCase 实例
-                use_case = UseCase(
-                    time=processed_time_str, # 使用清理后的原始时间字符串
-                    level=level_raw,
-                    timestamp=current_log_timestamp, # 传入 datetime 对象
-                    filepath=filepath_raw,
-                    function=function_raw,
-                    lines=lines_raw,
-                    type_=type_raw,
-                    target=target_raw,
-                    content=content_raw,
-                    is_deleted=False, # 默认值
-                )
-                session.add(use_case)
-                added_count += 1
-
-            except Exception as e:
-                print(f"Error processing log entry: {res_str}. Error: {e}")
-                error_count += 1
-                session.rollback() # 如果在添加过程中发生错误，回滚当前批次，避免污染 session
-                # 重新开始一个新的事务，或者处理这个错误
-
-        # 4. 提交事务
-        try:
-            await session.commit()
-            print(f"Log processing complete: Added {added_count} new entries, skipped {skipped_count} existing entries, encountered {error_count} errors.")
-        except Exception as e:
-            print(f"Error during final commit: {e}")
-            await session.rollback()
-
-    async def save_use_case(self,
-                             prompt_id: str,
-                             use_case:str = "",
-                             timestamp = "",
-                             output = "",
-                             solution: str = "",
-                             faired_time  = 0,
-                             session = None
-                            ):
-
-        """
-        从sql保存提示词
-        """
-        #TODO 存之前保证数据库中相同的prompt_id中没有重复的use_case
-        use_cases = await self.get_use_case(target_prompt_id = prompt_id,
-                                  session = session)
-        for use_case_old in use_cases:
-            if use_case == use_case_old.use_case:
-                # print("用例已经存在")
-                return 
-        #time,level, timestamp filepath, function lines, type_, target, content
-        with open("/Users/zhaoxuefeng/GitHub/digital_life/logs/app.log",'r') as f:
-            x = f.read()
-            resu = x.split("||")[14].split("$")
-
-        use_case = UseCase(
-            time = resu[0],
-            level = resu[1], 
-            timestamp =resu[2],
-            filepath=resu[3],
-            function=resu[4],
-            lines=resu[5],
-            type_=resu[6],
-            target=resu[7],
-            content=resu[8],
-        )
-
-
-
-        # use_case = UseCase(prompt_id=prompt_id,
-        #                 use_case = use_case,
-        #                 timestamp = timestamp,
-        #                 output = output,
-        #                 solution = solution,
-        #                 faired_time = faired_time,
-        #                 )
-
-        session.add(use_case)
-        await session.commit() # 提交事务，将数据写入数据库
-
-    async def push_action_order(self,demand : str,prompt_id: str,
-                         action_type = 'train'):# init
-
-        """
-        从sql保存提示词
-        推一个train 状态到指定的位置
+    async def adjust_prompt(self,prompt_id: str,action_type = "summary", demand: str = ""):
 
-        将打算修改的状态推上数据库 # 1
-        """
-        # 查看是否已经存在
-        async with create_async_session(self.engine) as session:
-
-            latest_prompt = await self.get_prompt_safe(prompt_id=prompt_id,session=session)
-            if latest_prompt:
-                await self.save_prompt(prompt_id=latest_prompt.prompt_id,
-                                    new_prompt = latest_prompt.prompt,
-                                    use_case = latest_prompt.use_case,
-                                    action_type=action_type,
-                                    demand=demand,
-                                    score=latest_prompt.score,
-                                    session=session
-                                    )
-                return "success"
-            else:
-                await self.save_prompt(prompt_id=prompt_id,
-                                    new_prompt = demand,
-                                    use_case = "",
-                                    action_type="inference",
-                                    demand=demand,
-                                    score=60,
-                                    session=session
-                                    )
-                return "init"
-
-
-    async def intellect(self,
-                    input_data: dict | str,
-                    output_format: str,
-                    prompt_id: str,
-                    version: str = None,
-                    change_case = False,
-                    ):
-        """
-        自定自动化执行命令的方法, 
-        不涉及严格的校验, 主要职能在自动化的修改提示词, 或者管理提示词上
-        """
-        if isinstance(input_data,dict):
-            input_ = json.dumps(input_data,ensure_ascii=False)
-        elif isinstance(input_data,str):
-            input_ = input_data
-        
         # 查数据库, 获取最新提示词对象
         async with create_async_session(self.engine) as session:
             result_obj = await self.get_prompt_safe(prompt_id=prompt_id,session=session)
-            if result_obj is None:
-                raise IntellectRemoveError("不存在的prompt_id")
 
             prompt = result_obj.prompt
-            if result_obj.action_type == "inference":
-                # 直接推理即可
-                ai_result = await self.llm.aproduct(prompt + output_format + "\nuser:" +  input_)
-                    
-            elif result_obj.action_type == "train":
-                assert result_obj.demand # 如果type = train 且 demand 是空 则报错
-                # 则训练推广
-
-                # 新版本 默人修改会 inference 状态
-            
+            use_case = result_obj.use_case
 
-                # assert demand
-                # # 注意, 这里的调整要求使用最初的那个输入, 最好一口气调整好
-                # chat_history = prompt
-                # if input_ == before_input: # 输入没变, 说明还是针对同一个输入进行讨论
-                #     # input_prompt = chat_history + "\nuser:" + demand
-                #     input_prompt = chat_history + "\nuser:" + demand + output_format 
-                # else:
-                #     # input_prompt = chat_history + "\nuser:" + demand + "\n-----input----\n" + input_
-                #     input_prompt = chat_history + "\nuser:" + demand + output_format  + "\n-----input----\n" + input_
-            
-                # ai_result = await self.llm.aproduct(input_prompt)
-                # chat_history = input_prompt + "\nassistant:\n" + ai_result # 用聊天记录作为完整提示词
-                # await self.save_prompt(prompt_id, chat_history,
-                #                         use_case = input_,
-                #                         score = 60,
-                #                         session = session)
-
-
-                # version 2
-
-                # if input_ == before_input:
-                #     new_prompt = prompt + "\nuser:" + demand
-                # else:
-                #     new_prompt = prompt + "\nuser:" + input_
-
-                # ai_result = await self.llm.aproduct(new_prompt + output_format)
-
-                # save_new_prompt = new_prompt + "\nassistant:\n" + ai_result
-
-
-                # await self.save_prompt(
-                #     prompt_id, 
-                #     new_prompt=save_new_prompt,
-                #     use_case = input_,
-                #     action_type = "inference",
-                #     score = 60,
-                #     session = session)
-                chat_history = prompt
-                before_input = result_obj.use_case
-                demand = result_obj.demand
-                input_data = input_
-                if before_input == "" or change_case is True:
-                    result_obj.use_case = input_
-                    await session.commit()
-                    # 查询上一条, 将before_input 更新位input_
-                    prompt += input_
-
-                # 使用更新后的数据进行后续步骤
-                new_prompt = prompt + "\nuser:" + demand
-
-                ai_result = await self.llm.aproduct(new_prompt + output_format)
-
-                save_new_prompt = new_prompt + "\nassistant:\n" + ai_result
-
-
-                await self.save_prompt(
-                    prompt_id, 
-                    new_prompt=save_new_prompt,
-                    use_case = input_,
-                    action_type = "inference",
-                    score = 60,
-                    session = session)
-    
-            elif result_obj.action_type == "summary":
+            if action_type == "summary":
                 system_prompt_summary = """        
 很棒, 我们已经达成了某种默契, 我们之间合作无间, 但是, 可悲的是, 当我关闭这个窗口的时候, 你就会忘记我们之间经历的种种磨合, 这是可惜且心痛的, 所以你能否将目前这一套处理流程结晶成一个优质的prompt 这样, 我们下一次只要将prompt输入, 你就能想起我们今天的磨合过程,
 对了,我提示一点, 这个prompt的主角是你, 也就是说, 你在和未来的你对话, 你要教会未来的你今天这件事, 是否让我看懂到时其次
@@ -704,24 +346,12 @@ class AsyncIntel():
 只要输出提示词内容即可, 不需要任何的说明和解释
 """
                 
-                latest_prompt = await self.get_prompt_safe(prompt_id=prompt_id,session=session)
-
                 system_result = await self.llm.aproduct(prompt + system_prompt_summary)
                 s_prompt = extract_(system_result,pattern_key=r"prompt")
                 new_prompt = s_prompt or system_result
-                await self.save_prompt(
-                    prompt_id,
-                    new_prompt = new_prompt,
-                    use_case = latest_prompt.use_case,
-                    score = 65,
-                    action_type = "inference",
-                    session = session
-                    )
-
-                ai_result = await self.llm.aproduct(prompt + output_format + "\nuser:" +  input_)
-
-            elif result_obj.action_type == "finetune":
-                demand = result_obj.demand
+                
+            elif action_type == "finetune":
+                assert demand
                 change_by_opinion_prompt = """
 你是一个资深AI提示词工程师，具备卓越的Prompt设计与优化能力。
 我将为你提供一段现有System Prompt。你的核心任务是基于这段Prompt进行修改，以实现我提出的特定目标和功能需求。
@@ -748,76 +378,45 @@ class AsyncIntel():
 功能需求:
 {opinion}
 """
+                new_prompt = await self.llm.aproduct(
+                    change_by_opinion_prompt.format(old_system_prompt=prompt, opinion=demand)
+                )
 
-                latest_prompt = await self.get_prompt_safe(prompt_id=prompt_id,session=session)
-                prompt_ = await self.get_prompt_safe(prompt_id = prompt_id,version = version,
-                                                                session=session)
+            elif action_type == "patch":
                 assert demand
-                
-                if demand:
-                        new_prompt = await self.llm.aproduct(
-                            change_by_opinion_prompt.format(old_system_prompt=prompt_.prompt, opinion=demand)
-                        )
-                else:
-                    new_prompt = prompt_ 
-                await self.save_prompt(
-                    prompt_id,
-                    new_prompt = new_prompt,
-                    use_case = latest_prompt.use_case,
-                    score = 70,
-                    action_type = "inference",
-                    session = session
-                    )
-                
-                ai_result = await self.llm.aproduct(prompt + output_format + "\nuser:" +  input_)
+                new_prompt = prompt + "\n"+demand,
 
-            elif result_obj.action_type == "patch":
-                demand = result_obj.demand
-                assert demand
-                latest_prompt = await self.get_prompt_safe(prompt_id=prompt_id,session=session)
-                
-                chat_history = prompt + demand
-                await self.save_prompt(prompt_id, 
-                                chat_history,
-                                use_case = latest_prompt.use_case,
-                                score = 70,
-                                action_type = "inference",
-                                session = session)
-                
-                ai_result = await self.llm.aproduct(chat_history + output_format + "\nuser:" +  input_)
-                
-            elif result_obj.action_type.startswith("to:"):
+            elif action_type.startswith("to:"):
                 target_version = result_obj.action_type.split(":")[-1]
-                latest_prompt = await self.get_prompt_safe(prompt_id=prompt_id,session=session)
                 prompt_obj = await self.get_prompt_safe(prompt_id=prompt_id,
                                      version=target_version,
                                      session=session)
                 
-                await self.save_prompt(prompt_id, 
-                                prompt_obj.prompt,
-                                use_case = latest_prompt.use_case,
-                                score = prompt_obj.score,
-                                action_type = "inference",
-                                session = session)
-                ai_result = await self.llm.aproduct(prompt_obj.prompt + output_format + "\nuser:" +  input_)
-                
-            elif result_obj.action_type == "pass":
-                pass
-            
+                new_prompt = prompt_obj.prompt
+
             else:
                 raise
 
-        return ai_result
-        
-    async def intellect_format(self,
+            await self.save_prompt(
+                prompt_id,
+                new_prompt = new_prompt,
+                use_case = use_case,
+                score = 70,
+                action_type = "inference",
+                session = session
+                )
+
+        return "success"
+
+    async def inference_format(self,
                     input_data: dict | str,
-                    OutputFormat: object | None,
                     prompt_id: str,
-                    ExtraFormats: list[object] = [],
                     version: str = None,
+                    OutputFormat: object | None = None,
+                    ExtraFormats: list[object] = [],
                     ConTent_Function = None,
                     AConTent_Function = None,
-                    logger = None,
+                    again = True,
                     ):
         """
         这个format 是严格校验模式, 是interllect 的增强版, 会主动校验内容,并及时抛出异常(或者伺机修正)
@@ -834,134 +433,175 @@ class AsyncIntel():
 "```json([\s\S]*?)```"
 使用以下方式验证
 """     
-        if OutputFormat:
-            output_format = base_format_prompt + "\n".join([inspect.getsource(outputformat) for outputformat in ExtraFormats]) + inspect.getsource(OutputFormat)
-        else:
-            output_format = ""
+        assert isinstance(input_data,(dict,str))
 
-        if logger:
-            logger.info(f'{type(input_data)} $ intellect-输入 $ {input_data} \noutput_format: \n{output_format}')
+        input_ = json.dumps(input_data,ensure_ascii=False) if isinstance(input_data,dict) else input_data
+        output_format = base_format_prompt + "\n".join([inspect.getsource(outputformat) for outputformat in ExtraFormats]) + inspect.getsource(OutputFormat) if OutputFormat else ""
+        self.logger and self.logger.info(get_log_info("intel-输入",input_data))
 
-        ai_result = await self.intellect(
-                    input_data=input_data,
-                    output_format=output_format,
-                    prompt_id=prompt_id,
-                    version=version,
-                )
-        if OutputFormat:
+        async with create_async_session(self.engine) as session:
+            result_obj = await self.get_prompt_safe(prompt_id=prompt_id,version= version,
+                                                    session=session)
+            prompt = result_obj.prompt
+            ai_result = await self.llm.aproduct(prompt + output_format + "\nuser:" +  input_)
+        
+        def check_json_valid(ai_result,OutputFormat):
             try:
                 json_str = extract_(ai_result,r'json')
                 ai_result = json.loads(json_str)
                 OutputFormat(**ai_result)
 
             except JSONDecodeError as e:
-                try:
-                    self.logger.error(f'{type(json_str)} $ intellect尝试补救 $ {json_str}')
-                    json_str = fix_broken_json_string(json_str)
-                    ai_result = json.loads(json_str)
-                    OutputFormat(**ai_result)
-
-                except JSONDecodeError as e:
-                    self.logger.error(f'{type(json_str)} $ {prompt_id}intellect生成的内容为无法被Json解析 $ {json_str}')
-                    raise IntellectRemoveFormatError(f"prompt_id: {prompt_id} 生成的内容为无法被Json解析 {e}") from e
-            
+                self.logger.error(f'{type(json_str)} $ {prompt_id}intellect生成的内容为无法被Json解析 $ {json_str}')
+                # raise IntellectRemoveFormatError(f"prompt_id: {prompt_id} 生成的内容为无法被Json解析 {e}") from e
+                return 0
             except ValidationError as e:
                 err_info = e.errors()[0]
-                raise IntellectRemoveFormatError(f"{err_info["type"]}: 属性:{err_info['loc']}, 发生了如下错误: {err_info['msg']}, 格式校验失败, 当前输入为: {err_info['input']} 请检查") from e
-
+                self.logger.error(f'{type(json_str)} $ {prompt_id}解析未通过OutputFormat $ {json_str}')
+                # raise IntellectRemoveFormatError(f"{err_info["type"]}: 属性:{err_info['loc']}, 发生了如下错误: {err_info['msg']}, 格式校验失败, 当前输入为: {err_info['input']} 请检查") from e
+                return 0
             except Exception as e:
                 raise Exception(f"Error {prompt_id} : {e}") from e
+            return 1
             
-        if ConTent_Function:
+        if OutputFormat:
+            check_result = check_json_valid(ai_result,OutputFormat)
+            if check_result ==0 and again:
+                ai_result = await self.llm.aproduct(ai_result + output_format)
+                check_result_ = check_json_valid(ai_result,OutputFormat)
+                if check_result_ ==0:
+                    raise IntellectRemoveFormatError(f"prompt_id: {prompt_id} 多次生成的内容均未通过OutputFormat校验, 当前内容为: {ai_result}")
+            json_str = extract_(ai_result,r'json')
+            ai_result = json.loads(json_str)
+                    
+        if ConTent_Function:# TODO
             ConTent_Function(ai_result,input_data)
         
         if AConTent_Function:
             await AConTent_Function(ai_result,input_data)
 
-        if logger:
-            logger.info(f'{type(ai_result)} $ intellect输出 ai_result $ {ai_result}')
+        self.logger and self.logger.info(f'{type(ai_result)} $ intellect输出 ai_result $ {ai_result}')
         return ai_result
     
-    async def intellect_formats(self,
+    async def inference_format_gather(self,
                     input_datas: list[dict | str],
-                    OutputFormat: object | None,
                     prompt_id: str,
-                    ExtraFormats: list[object] = [],
                     version: str = None,
+                    OutputFormat: object | None = None,
+                    ExtraFormats: list[object] = [],
                     **kwargs,
                     ):
                 
-        async with create_async_session(self.engine) as session:
-            prompt_result = await self.get_prompt_safe(prompt_id=prompt_id,
-                                                                   session=session)
-            if prompt_result is None:
-                raise IntellectRemoveError("不存在的prompt_id")
-        if prompt_result.action_type != "inference":
-            input_datas = input_datas[:1]
         tasks = []
         for input_data in input_datas:
             tasks.append(
-                self.intellect_format(
+                self.inference_format(
                     input_data = input_data,
                     prompt_id = prompt_id,
+                    version = version,
                     OutputFormat = OutputFormat,
                     ExtraFormats = ExtraFormats,
-                    version = version,
                     **kwargs,
                 )
             )
-        results = await asyncio.gather(*tasks, return_exceptions=False)
+        results = await tqdm.gather(*tasks,total=len(tasks))
+        # results = await asyncio.gather(*tasks, return_exceptions=False)
         return results
     
-    def intellect_warp(self,prompt_id: str):
-        def outer_packing(func):
-            @functools.wraps(func)
-            async def wrapper(*args, **kwargs):
-                # 修改逻辑
-                assert kwargs.get('input_data') # 要求一定要有data入参
-                input_data = kwargs.get('input_data')
-                kwargs.pop(input_data)
-                if isinstance(input_data,dict):
-                    input_ = output_ = json.dumps(input_data,ensure_ascii=False)
-                elif isinstance(input_data,str):
-                    input_ = output_ = input_data
-
-                output_ = await self.intellect_format(
-                        input_data = input_data,
-                        prompt_id = prompt_id,
-                        **kwargs,
-                        
+
+
+
+    async def get_use_case(self,
+                             target_prompt_id: str,
+                             start_time: datetime = None,  # 新增：开始时间
+                             end_time: datetime = None,    # 新增：结束时间
+                             session = None
+                            ):
+        """
+        从sql保存提示词
+        """
+        stmt = select(UseCase).filter(UseCase.is_deleted == 0,
+                                      UseCase.prompt_id == target_prompt_id)
+        
+        if start_time:
+            stmt = stmt.filter(UseCase.timestamp >= start_time)  # 假设你的UseCase模型有一个created_at字段
+
+        if end_time:
+            stmt = stmt.filter(UseCase.timestamp <= end_time)
+        result = await session.execute(stmt)
+        # use_case = result.scalars().one_or_none()
+        use_case = result.scalars().all()
+        return use_case
+
+    async def save_use_case(self,log_file,session = None):
+        with open(log_file,'r') as f:
+            x = f.read()
+
+        def deal_log(resu):
+            if len(resu) <3:
+                return 
+            try:  
+                create_time = resu[1]
+                level = resu[2]
+                funcname = resu[3]
+                line = resu[4]
+                pathname = resu[5]
+                message = resu[6]
+
+                message_list = message.split("&")
+                if len(message_list) == 3:
+                    target, type_, content = message_list
+                elif len(message_list) == 2:
+                    target, type_ = message_list
+                    content = "只有两个"
+                elif len(message_list) == 1:
+                    target = message_list[0]
+                    type_ = " "
+                    content = "只有一个"
+
+                dt_object = datetime.datetime.fromtimestamp(float(create_time.strip()))
+                use_case = UseCase(
+                    time = create_time,
+                    level = level,
+                    timestamp =dt_object.strftime('%Y-%m-%d %H:%M:%S.%f'),
+                    filepath=pathname,
+                    function=funcname,
+                    lines=line,
+                    type_=type_,
+                    target=target,
+                    content=content,
                 )
+                session.add(use_case)
+            except Exception as e:
+                print(resu,'resu')
+                raise
+
+
+        for res in x.split("||"):
+            resu = res.split("$")
+            deal_log(resu)
+
+        await session.commit() # 提交事务，将数据写入数据库
 
-                #######
-                kwargs.update({"input_data":output_})
-                result = await func(*args, **kwargs)
-                return result
-            return wrapper
-        return outer_packing
 
     async def intellect_format_eval(self,
-                    OutputFormat: object,
                     prompt_id: str,
+                    version: str = None,
                     database_url = None,
+                    OutputFormat: object = None,
                     ExtraFormats: list[object] = [],
-                    version: str = None,
                     MIN_SUCCESS_RATE = 80.0,
                     ConTent_Function = None,
                     AConTent_Function = None,
+                    start = None,
+                    end = None,
                     ):
-        """
-        ConTent_Function: 
-        # TODO 人类评价 eval
-        # TODO llm 评价 eval
-        """
+        # start = datetime(2023, 1, 1, 10, 0, 0)
+        # end = datetime(2023, 1, 15, 12, 30, 0)
         async with create_async_session(self.engine) as session:
             prompt_result = await self.get_prompt_safe(prompt_id=prompt_id,
-                                                                   session=session)
-            if prompt_result is None:
-                raise IntellectRemoveError("不存在的prompt_id")
-            if prompt_result.action_type != "inference":
-                raise IntellectRemoveError("请在inference模式下使用次类")
+                                                       version = version,
+                                                        session=session)
 
         if database_url:
             eval_engine = create_async_engine(database_url, echo=False,
@@ -973,12 +613,11 @@ class AsyncIntel():
                                         )
         else:
             eval_engine = self.engine
+
         async with create_async_session(eval_engine) as eval_session:
-            # start = datetime(2023, 1, 1, 10, 0, 0)
-            # end = datetime(2023, 1, 15, 12, 30, 0)
             use_cases = await self.get_use_case(target_prompt_id=prompt_id,session=eval_session,
-                                                start_time=None,
-                                                end_time=None,)
+                                                start_time=start,
+                                                end_time=end,)
 
             total_assertions = len(use_cases)
             result_cases = []
@@ -1038,21 +677,13 @@ class AsyncIntel():
 
             success_rate = (successful_assertions / total_assertions) * 100
 
+            status = "通过" if success_rate >= MIN_SUCCESS_RATE else "未通过"
 
-            if success_rate >= MIN_SUCCESS_RATE:
-                self.eval_df.loc[len(self.eval_df)] = {"name":prompt_id,
-                                                   'status':"通过",
+            self.eval_df.loc[len(self.eval_df)] = {"name":prompt_id,
+                                                   'status':status,
                                                    "score":success_rate,
                                                    "total":str(total_assertions),
                                                    "bad_case":json.dumps(bad_case,ensure_ascii=False)}
-                return "通过", success_rate, str(total_assertions), json.dumps(bad_case,ensure_ascii=False),
-            else:
-                self.eval_df.loc[len(self.eval_df)] = {"name":prompt_id,
-                                                   'status':"未通过",
-                                                   "score":success_rate,
-                                                   "total":str(total_assertions),
-                                                   "bad_case":json.dumps(bad_case,ensure_ascii=False)}
-                return "未通过",success_rate, str(total_assertions), json.dumps(bad_case,ensure_ascii=False),
 
 
     async def function_eval(self,
@@ -1071,12 +702,8 @@ class AsyncIntel():
         # TODO llm 评价 eval
         """
         async with create_async_session(self.engine) as session:
-            prompt_result = await self.get_prompt_safe(prompt_id=prompt_id,
+            await self.get_prompt_safe(prompt_id=prompt_id,
                                                                    session=session)
-            if prompt_result is None:
-                raise IntellectRemoveError("不存在的prompt_id")
-            if prompt_result.action_type != "inference":
-                raise IntellectRemoveError("请在inference模式下使用次类")
 
         if database_url:
             eval_engine = create_async_engine(database_url, echo=False,