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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pro-craft
-Version: 0.1.56
+Version: 0.2.57
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

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

@@ -1,6 +1,6 @@
 [project]
 name = "pro-craft"
-version = "0.1.56"
+version = "0.2.57"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

pro_craft-0.2.57/src/pro_craft/__init__.py

@@ -0,0 +1,10 @@
+from dotenv import load_dotenv, find_dotenv
+dotenv_path = find_dotenv()
+load_dotenv(".env", override=True)
+
+from .log import Log
+Log_ = Log(console_level = 30, # 显示控制台的等级 WARNING 
+             log_file_name="app.log")
+logger = Log_.logger
+
+from .prompt_craft import AsyncIntel, Intel, IntelNew

{pro_craft-0.1.56 → pro_craft-0.2.57}/src/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,48 @@ 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,
+    type_ = Column(
+        String(255),             # TEXT 类型，适用于长文本
         nullable=False,     # 不能为空
-        comment="失败次数"
+        comment="函数"
     )
 
-    total = Column(
-        Integer,
+    target = Column(
+        Text,      # 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-0.2.57/src/pro_craft/log.py

@@ -0,0 +1,111 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+import inspect
+class Log:
+    _instance = None
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    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
+        self.LOG_FILE_PATH = os.path.join("logs", log_file_name)
+        self.logger = self.get_logger()
+
+    def get_logger(self):
+        logger = logging.getLogger()
+        # logger.setLevel(self.LOG_LEVEL)
+        if not logger.handlers:
+            # --- 4. 配置 Formatter (格式化器) ---
+            # 以后有一个标准化的日志要使用logger 而非标的则使用super-log
+            formatter = logging.Formatter(
+                "%(asctime)s $ %(levelname)s $ %(created)f $ %(pathname)s $ %(funcName)s$ :%(lineno)d $ %(message)s||"
+            )
+            # --- 5. 配置 Handler (处理器) ---
+
+            # 5.1 控制台处理器 (StreamHandler)
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(self.Console_LOG_LEVEL)  # 控制台只显示 INFO 及以上级别的日志
+            console_handler.setFormatter(formatter)
+            logger.addHandler(console_handler)
+
+
+            # 文件系统
+            ## 主日志本
+            file_handler = RotatingFileHandler(  # RotatingFileHandler: 按文件大小轮转
+                self.LOG_FILE_PATH,
+                maxBytes=10 * 1024 * 1024,  # 10 MB # maxBytes: 单个日志文件的最大字节数 (例如 10MB)
+                backupCount=10, # backupCount: 保留的旧日志文件数量
+                encoding="utf-8",
+            )
+            file_handler.setLevel(logging.DEBUG)  # 文件中显示所有指定级别的日志
+            file_handler.setFormatter(formatter)
+            logger.addHandler(file_handler)
+
+            ## 运行日志本
+            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_warning = RotatingFileHandler(
+                self.LOG_FILE_PATH.replace('.log','_err.log'),
+                maxBytes=10 * 1024 * 1024,  # 10 MB
+                backupCount=5,
+                encoding="utf-8",
+            )
+            file_handler_warning.setLevel(logging.WARNING)  # 文件中显示所有指定级别的日志
+            file_handler_warning.setFormatter(formatter)
+            logger.addHandler(file_handler_warning)
+
+            ## 指定日志本 
+            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_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 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

{pro_craft-0.1.56 → pro_craft-0.2.57}/src/pro_craft/prompt_craft/async_.py

@@ -26,14 +26,12 @@ from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sess
 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)
+BATCH_SIZE = int(os.getenv("DATABASE_SYNC_BATCH_SIZE",1000))
 
 def fix_broken_json_string(broken_json_str):
     # 移除 BOM
@@ -119,7 +117,6 @@ class AsyncIntel():
             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,
@@ -287,7 +284,6 @@ class AsyncIntel():
         if prompt_obj:
             return prompt_obj
 
-        print("warnning 未找到制定版本, 默认使用最新版本")
         prompt_obj = await self.get_prompt(prompt_id=prompt_id,version=None,session=session)
         return prompt_obj
 
@@ -354,6 +350,170 @@ class AsyncIntel():
         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 = "",
@@ -374,14 +534,32 @@ class AsyncIntel():
             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,
-                        )
+        #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() # 提交事务，将数据写入数据库
@@ -426,7 +604,6 @@ class AsyncIntel():
                     output_format: str,
                     prompt_id: str,
                     version: str = None,
-                    inference_save_case = True,
                     change_case = False,
                     ):
         """
@@ -448,16 +625,6 @@ class AsyncIntel():
             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 是空 则报错
@@ -636,6 +803,7 @@ class AsyncIntel():
                 
             elif result_obj.action_type == "pass":
                 pass
+            
             else:
                 raise
 
@@ -647,7 +815,6 @@ class AsyncIntel():
                     prompt_id: str,
                     ExtraFormats: list[object] = [],
                     version: str = None,
-                    inference_save_case = True,
                     ConTent_Function = None,
                     AConTent_Function = None,
                     logger = None,
@@ -680,7 +847,6 @@ class AsyncIntel():
                     output_format=output_format,
                     prompt_id=prompt_id,
                     version=version,
-                    inference_save_case=inference_save_case,
                 )
         if OutputFormat:
             try:
@@ -722,7 +888,6 @@ class AsyncIntel():
                     prompt_id: str,
                     ExtraFormats: list[object] = [],
                     version: str = None,
-                    inference_save_case = True,
                     **kwargs,
                     ):
                 
@@ -742,7 +907,6 @@ class AsyncIntel():
                     OutputFormat = OutputFormat,
                     ExtraFormats = ExtraFormats,
                     version = version,
-                    inference_save_case = inference_save_case,
                     **kwargs,
                 )
             )
@@ -829,7 +993,6 @@ class AsyncIntel():
                         OutputFormat = OutputFormat,
                         ExtraFormats = ExtraFormats,
                         version = version,
-                        inference_save_case = False,
                         ConTent_Function = ConTent_Function,
                         AConTent_Function = AConTent_Function,
                     )
@@ -941,7 +1104,6 @@ class AsyncIntel():
                         OutputFormat = OutputFormat,
                         ExtraFormats = ExtraFormats,
                         version = version,
-                        inference_save_case = False,
                         ConTent_Function = ConTent_Function,
                         AConTent_Function = AConTent_Function,
                     )

{pro_craft-0.1.56 → pro_craft-0.2.57}/src/pro_craft/server/router/prompt.py

@@ -167,7 +167,26 @@ def create_router(database_url: str,
                 status_code=500, detail=f"{e}"
             )
         
+    @router.post("/update_logs",
+                description="回滚现行提示词",
+                response_model=PromptResponse)
+    async def roll_back22(request: RollBackPromptRequest):
+        try:
+            async with create_async_session(intels.engine) as session:
 
+                await intels.save_prompt(
+                                prompt_id = request.prompt_id,
+                                new_prompt = result.prompt,
+                                use_case = result.use_case,
+                                action_type = "inference",
+                                demand = "",
+                                score = 61,
+                                session = session)
+            return PromptResponse(msg = "success",content="")
+        except Exception as e:
+            raise HTTPException(
+                status_code=500, detail=f"{e}"
+            )
     #系统级别服务
     
     @router.post("/sync_database")

{pro_craft-0.1.56 → pro_craft-0.2.57}/src/pro_craft.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pro-craft
-Version: 0.1.56
+Version: 0.2.57
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

pro_craft-0.1.56/src/pro_craft/__init__.py

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

pro_craft-0.1.56/src/pro_craft/log.py

@@ -1,82 +0,0 @@
-import logging
-import os
-from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
-
-class Log:
-    _instance = None
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    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)
-        self.logger = self.get_logger()
-        self.super_log_level = self.logger.critical
-
-    def get_logger(self):
-        logger = logging.getLogger()
-        # logger.setLevel(self.LOG_LEVEL)
-        if not logger.handlers:
-            # --- 4. 配置 Formatter (格式化器) ---
-            formatter = logging.Formatter(
-                "%(asctime)s - %(levelname)s - %(name)s - %(funcName)s - %(module)s:%(lineno)d - %(message)s"
-            )
-            # --- 5. 配置 Handler (处理器) ---
-
-            # 5.1 控制台处理器 (StreamHandler)
-            console_handler = logging.StreamHandler()
-            console_handler.setLevel(self.Console_LOG_LEVEL)  # 控制台只显示 INFO 及以上级别的日志
-            console_handler.setFormatter(formatter)
-            logger.addHandler(console_handler)
-
-
-            # 文件
-
-            # 5.2 信息数据
-
-            # RotatingFileHandler: 按文件大小轮转
-            # maxBytes: 单个日志文件的最大字节数 (例如 10MB)
-            # backupCount: 保留的旧日志文件数量
-            file_handler = RotatingFileHandler(
-                self.LOG_FILE_PATH,
-                maxBytes=10 * 1024 * 1024,  # 10 MB
-                backupCount=5,
-                encoding="utf-8",
-            )
-            file_handler.setLevel(logging.INFO)  # 文件中显示所有指定级别的日志
-            file_handler.setFormatter(formatter)
-            logger.addHandler(file_handler)
-
-            # 5.3 错误警告日志
-
-            file_handler_debug = 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_cri = RotatingFileHandler(
-                self.LOG_FILE_PATH.replace('.log','_slog.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
-
-    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}")
-