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

pro_craft/prompt_craft/async_.py

@@ -1,39 +1,37 @@
 # 测试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 # 用于检查对象是否是持久化的
 from datetime import datetime, timedelta
-
+import datetime
 from tqdm.asyncio import tqdm
 import pandas as pd
 import plotly.graph_objects as go
-from pro_craft import super_log
 
-BATCH_SIZE = int(os.getenv("DATABASE_SYNC_BATCH_SIZE",100))
-print(12)
+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):
     # 移除 BOM
@@ -114,12 +112,11 @@ 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
         except AssertionError as e:
-            super_log(database_url,'database_url',logger=self.logger.warning)
             raise IntellectRemoveFormatError(f"异步服务url必须提供, 且必须是aiomysql配置") from e
 
         self.engine = create_async_engine(database_url, echo=False,
@@ -159,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) 
@@ -275,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,
@@ -286,12 +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)
 
-        print("warnning 未找到制定版本, 默认使用最新版本")
-        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,
@@ -332,204 +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_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 
-        
-        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 状态到指定的位置
-
-        将打算修改的状态推上数据库 # 1
-        """
-        # 查看是否已经存在
-        async with create_async_session(self.engine) as session:
+    async def adjust_prompt(self,prompt_id: str,action_type = "summary", demand: str = ""):
 
-            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,
-                    inference_save_case = True,
-                    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_)
-                if inference_save_case:
-                    # 设计一个机制, 传输说获取300数据, 那么数据就一直流转获取, 知道300截止
-                    await self.save_use_case(prompt_id,
-                                        use_case = input_,
-                                        timestamp = datetime.now(),
-                                        output = ai_result,
-                                        solution = output_format,
-                                        faired_time = 0,
-                                        session = session,
-                                        )
-                    
-            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的主角是你, 也就是说, 你在和未来的你对话, 你要教会未来的你今天这件事, 是否让我看懂到时其次
@@ -537,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进行修改，以实现我提出的特定目标和功能需求。
@@ -581,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,
-                    inference_save_case = True,
+                    OutputFormat: object | None = None,
+                    ExtraFormats: list[object] = [],
                     ConTent_Function = None,
                     AConTent_Function = None,
-                    logger = None,
+                    again = True,
                     ):
         """
         这个format 是严格校验模式, 是interllect 的增强版, 会主动校验内容,并及时抛出异常(或者伺机修正)
@@ -667,137 +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,
-                    inference_save_case=inference_save_case,
-                )
-        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,
-                    inference_save_case = True,
+                    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,
-                    inference_save_case = inference_save_case,
                     **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,
@@ -809,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 = []
@@ -829,7 +632,6 @@ class AsyncIntel():
                         OutputFormat = OutputFormat,
                         ExtraFormats = ExtraFormats,
                         version = version,
-                        inference_save_case = False,
                         ConTent_Function = ConTent_Function,
                         AConTent_Function = AConTent_Function,
                     )
@@ -875,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,
@@ -908,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,
@@ -941,7 +731,6 @@ class AsyncIntel():
                         OutputFormat = OutputFormat,
                         ExtraFormats = ExtraFormats,
                         version = version,
-                        inference_save_case = False,
                         ConTent_Function = ConTent_Function,
                         AConTent_Function = AConTent_Function,
                     )