agentic-kit-common 0.0.3__tar.gz → 0.0.17__tar.gz

{agentic_kit_common-0.0.3 → agentic_kit_common-0.0.17}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: agentic-kit-common
-Version: 0.0.3
-Summary: Common utilities and tools for agentic kit ecosystem, including MinIO manager and other shared components
+Version: 0.0.17
+Summary: Common utilities and tools for agentic kit ecosystem
 Home-page: 
 Author: manson
 Author-email: manson.li3307@gmail.com
@@ -24,8 +24,15 @@ Requires-Dist: langchain_core
 Requires-Dist: langgraph
 Requires-Dist: langchain_community
 Requires-Dist: langchain_experimental
+Requires-Dist: langchain-openai
 Requires-Dist: mysql-connector-python
 Requires-Dist: sqlalchemy
+Requires-Dist: sqlglot
+Requires-Dist: pymilvus
+Requires-Dist: xinference_client
+Requires-Dist: pymongo
+Requires-Dist: aliyun-python-sdk-core
+Requires-Dist: aliyun-python-sdk-dysmsapi
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

agentic_kit_common-0.0.17/agentic_kit_common/llm/__init__.py

@@ -0,0 +1,2 @@
+from .openai import create_openai_llm
+from .utils import combine_simple_context

agentic_kit_common-0.0.17/agentic_kit_common/llm/openai.py

@@ -0,0 +1,33 @@
+import os
+
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+
+load_dotenv()
+
+
+model_name = os.getenv("MODEL_NAME", None)
+openai_api_base = os.getenv("OPENAI_API_BASE", None)
+openai_api_key = os.getenv("OPENAI_API_KEY", 'API_KEY')
+temperature = float(os.getenv("TEMPERATURE", 0.2))
+
+
+def create_openai_llm(**kwargs):
+    _model_name = kwargs.pop('model_name', model_name)
+    _openai_api_base = kwargs.pop('openai_api_base', openai_api_base)
+    _openai_api_key = kwargs.pop('openai_api_key', openai_api_key)
+    if not _openai_api_key:
+        _openai_api_key = 'API_KEY'
+    _temperature = kwargs.pop('temperature', temperature)
+
+    assert model_name is not None
+    assert openai_api_base is not None
+
+    llm = ChatOpenAI(
+        model_name=_model_name,
+        openai_api_base=_openai_api_base,
+        openai_api_key=_openai_api_key,
+        temperature=_temperature,
+        **kwargs
+    )
+    return llm

agentic_kit_common-0.0.17/agentic_kit_common/llm/utils.py

@@ -0,0 +1,61 @@
+import json
+import re
+from typing import Any, Dict, List, Union
+
+from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage
+
+
+def combine_simple_context(system: str, user: str = None):
+    context: List[Union[BaseMessage, dict[str, Any]]] = [SystemMessage(content=system)]
+    if user:
+        context.append(HumanMessage(content=system))
+    return context
+
+
+def fix_json_response(text: str) -> Union[Dict, List, str, int, float, bool, None]:
+    """
+    去掉大模型返回的 ```json / ``` 等 markdown 标记，并安全反序列化 JSON。
+    若解析失败，返回原字符串。
+
+    参数
+    ----
+    text : str
+        原始响应，可能包含 ```json ... ``` 或其他变体。
+
+    返回
+    ----
+    Python 对象（dict / list / str / int / float / bool / None）
+        解析失败时返回输入字符串本身。
+    """
+    if not isinstance(text, str):
+        return text
+
+    # 1. 去掉 ```json 或 ``` 包裹（支持开头、结尾、单行、多行）
+    cleaned = re.sub(r'^\s*```(?:json|JSON)?\s*\n?', '', text)
+    cleaned = re.sub(r'\n?\s*```\s*$', '', cleaned)
+
+    # 2. 去掉首尾空白
+    cleaned = cleaned.strip()
+
+    # 3. 尝试 JSON 反序列化
+    try:
+        json.loads(cleaned)
+        return cleaned
+    except json.JSONDecodeError:
+        # 4. 兜底：返回原字符串
+        return text
+
+
+# ----------------- 使用示例 -----------------
+if __name__ == "__main__":
+    demo_list = [
+        '```json\n{"a": 1, "b": "hello"}\n```',
+        "```JSON{'key': 'value'}```",
+        "```\n[1, 2, 3]```",
+        "plain text",
+        {"already_dict": 1},
+    ]
+    for d in demo_list:
+        print("原始:", repr(d))
+        print("修复:", repr(fix_json_response(d)))
+        print("-" * 30)

agentic_kit_common-0.0.17/agentic_kit_common/log/logger.py

@@ -0,0 +1,69 @@
+import logging
+import os
+import uuid
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+from typing import Union
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+logger_root_path = os.getenv("LOGGER_ROOT_PATH", None)
+log_dir = None
+
+if logger_root_path:
+    if logger_root_path.endswith('/'):
+        log_dir = f"{logger_root_path}logs"
+    else:
+        log_dir = f"{logger_root_path}/logs"
+    Path(log_dir).mkdir(parents=True, exist_ok=True)
+
+
+class LogUtils:
+    _handlers = {}
+
+    # 日志文件根据日期创建
+    # 根据参数name，将message写入对应的日志文件内
+    @classmethod
+    def log(cls, name: str="log", message: str="", log_uuid: str = str(uuid.uuid4()), level: Union[int, str] = logging.INFO) -> None:
+        if not log_dir:
+            return
+
+        try:
+            logger = logging.getLogger(name)
+            logger.setLevel(level)
+            logger.propagate = False
+            if name not in cls._handlers:
+                # 保证日志文件存在
+                # LOG_DIR.mkdir(parents=True, exist_ok=True)
+                # print(f"Log directory created at: {LOG_DIR}")
+                handler = TimedRotatingFileHandler(f'{log_dir}/{name}.log',  # 基础文件名
+                            when='midnight',  # 每天午夜
+                            interval=1,
+                            backupCount=7,  # 保留7天
+                            encoding='utf-8'
+                        )
+                formatter = logging.Formatter('%(uuid)s - %(asctime)s - %(name)s - %(levelname)s - %(message)s')
+                handler.setFormatter(formatter)
+                handler.setLevel(level)
+
+                # 控制台日志
+                stream_handler = logging.StreamHandler()
+                stream_handler.setLevel(level)
+                stream_formatter = logging.Formatter('%(uuid)s - %(asctime)s - %(name)s - %(levelname)s - %(message)s')
+                stream_handler.setFormatter(stream_formatter)
+                if not logger.hasHandlers():
+                    logger.addHandler(handler)
+                    logger.addHandler(stream_handler)
+                cls._handlers[name] = handler
+
+            req_id =  log_uuid or str(uuid.uuid4())
+            logger.log(level, message, extra={'uuid': req_id})  # 使用UUID
+
+            for handler in logger.handlers:
+                handler.flush()
+        except Exception as e:
+            # note: ignore error
+            pass

agentic_kit_common-0.0.17/agentic_kit_common/mongodb/__init__.py

@@ -0,0 +1,2 @@
+from .mongodb_manager import MongodbConfig
+from .mongodb_manager import MongodbManager

agentic_kit_common-0.0.17/agentic_kit_common/mongodb/mongodb_manager.py

@@ -0,0 +1,294 @@
+import logging
+from typing import Any, List, Dict, Optional, Tuple
+
+from pydantic import BaseModel, Field
+from pymongo import MongoClient
+from pymongo.collection import Collection
+from pymongo.database import Database
+from pymongo.errors import PyMongoError, AutoReconnect
+
+
+class MongodbConfig(BaseModel):
+    """
+    Config for mongodb.
+    """
+
+    host: str = Field(..., description="MongoDB服务器地址")
+    port: Optional[int] = Field(27017, description="MongoDB服务器端口")
+    database: Optional[str] = Field('default', description="数据库名称")
+    collection_name: Optional[str] = Field('default', description="集合名称")
+
+    username: Optional[str] = Field(None, description="MongoDB用户名")
+    password: Optional[str] = Field(None, description="MongoDB密码")
+    ssl: Optional[bool] = Field(False, description="是否使用SSL连接")
+
+    max_pool_size: Optional[int] = Field(20, description="最大连接池大小")
+    min_pool_size: Optional[int] = Field(5, description="最小连接池大小")
+    wait_queue_timeout_ms: Optional[int] = Field(60000, description="等待队列超时时间，单位毫秒")
+    server_selection_timeout_ms: Optional[int] = Field(3000, description="服务器选择超时时间,单位毫秒")
+
+
+class MongodbManager:
+    @classmethod
+    def create(cls, config: MongodbConfig):
+        return cls(config=config)
+
+    def __init__(self, config: MongodbConfig):
+        """
+        初始化 MongoDB 客户端
+        """
+
+        self.host = config.host
+        self.port = config.port
+        self.database = config.database
+        self.username = config.username
+        self.password = config.password
+        self.ssl = config.ssl
+        self.max_pool_size = config.max_pool_size
+        self.min_pool_size = config.min_pool_size
+        self.wait_queue_timeout_ms = config.wait_queue_timeout_ms
+        self.server_selection_timeout_ms = config.server_selection_timeout_ms
+
+        if self.username and self.password:
+            uri = f'mongodb://{self.username}:{self.password}@{self.host}:{self.port}'
+        else:
+            uri = f'mongodb://{self.host}:{self.port}'
+
+        self.client = MongoClient(
+            uri,
+            maxPoolSize=self.max_pool_size,
+            minPoolSize=self.min_pool_size,
+            waitQueueTimeoutMS=self.wait_queue_timeout_ms,
+            serverSelectionTimeoutMS=self.server_selection_timeout_ms,
+            ssl=self.ssl,
+        )
+        self.db: Database = self.client[self.database]
+        self.logger = logging.getLogger('MongodbManager')
+
+    def get_collection(self, collection_name: str) -> Collection:
+        """
+        获取集合
+        :param collection_name: 集合名称
+        :return: 集合对象
+        """
+        return self.db[collection_name]
+
+    def create_collection(self, collection_name: str) -> Collection:
+        """
+        获取集合
+        :param collection_name: 集合名称
+        :return: 集合对象
+        """
+        collection_names = self.db.list_collection_names()
+        if collection_name not in collection_names:
+            return self.db.create_collection(name=collection_name)
+        else:
+            return self.get_collection(collection_name)
+
+    def insert_one(self, collection_name: str, document: Dict) -> Any:
+        """
+        插入单个文档
+        :param collection_name: 集合名称
+        :param document: 要插入的文档
+        :return: 插入结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.insert_one(document)
+
+    def insert_many(self, collection_name: str, documents: List[Dict]) -> Any:
+        """
+        插入多个文档
+        :param collection_name: 集合名称
+        :param documents: 要插入的文档列表
+        :return: 插入结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.insert_many(documents)
+
+    def find_one(self, collection_name: str, filter: Optional[Dict] = None, exlude: Optional[Dict] = None) -> Any:
+        """
+        查询单个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :return: 查询结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.find_one(filter, exlude)
+
+    def find(self, collection_name: str, filter: Optional[Dict] = None, limit: int = 0, skip: int = 0, exlude: Optional[Dict] = None) -> List[Dict]:
+        """
+        查询多个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :param limit: 查询结果数量限制
+        :param skip: 跳过的结果数量
+        :return: 查询结果列表
+        """
+        collection = self.get_collection(collection_name)
+        return list(collection.find(filter, exlude).limit(limit).skip(skip))
+
+    def update_one(self, collection_name: str, filter: Dict, update: Dict) -> Any:
+        """
+        更新单个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :param update: 更新内容
+        :return: 更新结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.update_one(filter, update)
+
+    def update_many(self, collection_name: str, filter: Dict, update: Dict) -> Any:
+        """
+        更新多个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :param update: 更新内容
+        :return: 更新结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.update_many(filter, update)
+
+    def delete_one(self, collection_name: str, filter: Dict) -> Any:
+        """
+        删除单个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :return: 删除结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.delete_one(filter)
+
+    def delete_many(self, collection_name: str, filter: Dict) -> Any:
+        """
+        删除多个文档
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :return: 删除结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.delete_many(filter)
+
+    def count_documents(self, collection_name: str, filter: Optional[Dict] = None) -> int:
+        """
+        统计文档数量
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :return: 文档数量
+        """
+        collection = self.get_collection(collection_name)
+        return collection.count_documents(filter)
+
+    def create_index(self, collection_name: str, keys: List[Tuple[str, int]]) -> Any:
+        """
+        创建索引
+        :param collection_name: 集合名称
+        :param keys: 索引键列表，例如 [("field1", 1), ("field2", -1)]
+        :return: 索引创建结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.create_index(keys)
+
+    def drop_collection(self, collection_name: str) -> None:
+        """
+        删除集合
+        :param collection_name: 集合名称
+        """
+        self.db.drop_collection(collection_name)
+
+    def close(self) -> None:
+        """
+        关闭 MongoDB 客户端连接
+        """
+        self.client.close()
+
+    def start_session(self):
+        """
+        开始一个新的会话
+        :return: 会话对象
+        """
+        return self.client.start_session()
+
+    def start_transaction(self, session):
+        """
+        开始一个新的事务
+        :param session: 会话对象
+        """
+        session.start_transaction()
+
+    def commit_transaction(self, session):
+        """
+        提交事务
+        :param session: 会话对象
+        """
+        session.commit_transaction()
+
+    def abort_transaction(self, session):
+        """
+        回滚事务
+        :param session: 会话对象
+        """
+        session.abort_transaction()
+
+    def end_session(self, session):
+        """
+        结束会话
+        :param session: 会话对象
+        """
+        session.end_session()
+
+    def bulk_write(self, collection_name: str, requests: List) -> Any:
+        """
+        批量写入操作
+        :param collection_name: 集合名称
+        :param requests: 批量写入请求列表
+        :return: 批量写入结果
+        """
+        collection = self.get_collection(collection_name)
+        return collection.bulk_write(requests)
+
+    def find_with_pagination(self, collection_name: str, filter: Optional[Dict] = None, page: int = 1, page_size: int = 10) -> List[Dict]:
+        """
+        分页查询
+        :param collection_name: 集合名称
+        :param filter: 查询条件
+        :param page: 当前页码
+        :param page_size: 每页大小
+        :return: 查询结果列表
+        """
+        collection = self.get_collection(collection_name)
+        skip = (page - 1) * page_size
+        return list(collection.find(filter).skip(skip).limit(page_size))
+
+    def _execute_with_retry(self, func, *args, **kwargs):
+        """
+        带重试机制的执行函数
+        :param func: 要执行的函数
+        :param args: 位置参数
+        :param kwargs: 关键字参数
+        :return: 函数执行结果
+        """
+        max_retries = 3
+        retries = 0
+        while retries < max_retries:
+            try:
+                return func(*args, **kwargs)
+            except AutoReconnect as e:
+                self.logger.warning(f"AutoReconnect occurred: {e}")
+                retries += 1
+        raise PyMongoError(f"Failed after {max_retries} retries")
+
+
+if __name__ == '__main__':
+    config = MongodbConfig(
+        host='45.120.102.142',
+        port=8883,
+    )
+    manager = MongodbManager.create(config)
+    print(manager)
+    col = manager.get_collection('default')
+    print(col)
+    res = manager.insert_one('default', {'content': 'test content'})
+    print(res)
+    doc = manager.find_one('default')
+    print(doc)

agentic_kit_common-0.0.17/agentic_kit_common/orm/execution.py

@@ -0,0 +1,90 @@
+from typing import List, Union, Optional, Set
+
+import sqlglot
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+from sqlglot import expressions
+
+
+def get_operation_type(statement) -> str:
+    """获取SQL操作类型"""
+    return type(statement).__name__.upper()
+
+
+def get_sql_operation_info(sql: str) -> Optional[dict]:
+    """
+    获取SQL操作信息（用于调试和日志记录）
+
+    Returns:
+        dict: 包含操作类型、涉及表等信息
+    """
+    try:
+        statement = sqlglot.parse_one(sql, read="mysql")
+        operation_type = get_operation_type(statement)
+
+        tables = []
+        for table in statement.find_all(expressions.Table):
+            table_name = table.name
+            if table_name.startswith('`') and table_name.endswith('`'):
+                table_name = table_name[1:-1]
+            tables.append(table_name)
+
+        return {
+            'operation': operation_type,
+            'tables': tables,
+            'has_wildcard': bool(statement.find(expressions.Star)) if isinstance(statement, expressions.Select) else False
+        }
+    except Exception as e:
+        print(f"获取SQL操作信息失败: {e}")
+        return None
+
+
+def is_readonly_expression(node: expressions.Expression, allowed_operations: Optional[Set[str]] = None, enable_wildcard_check: bool = True):
+    """递归检查表达式树中是否出现写操作节点"""
+    # 写操作黑名单节点类型
+    write_types = {
+        expressions.Insert,
+        expressions.Update,
+        expressions.Delete,
+        expressions.Create,
+        expressions.Alter,
+        expressions.Drop,
+        expressions.Replace,
+        expressions.Merge
+    }
+    for descendant in node.walk():
+        if type(descendant) in write_types:
+            return False, type(descendant)
+
+    if allowed_operations:
+        op_type = get_operation_type(node)
+        # 检查操作类型
+        if op_type.lower() not in allowed_operations and op_type.upper() not in allowed_operations:
+            return False, op_type
+
+    if enable_wildcard_check and isinstance(node, expressions.Select) and node.find(expressions.Star):
+        return False, expressions.Star
+
+    return True, None
+
+
+def session_sql_execute(db_session: Session, sql_text: Union[str, List], format_result: bool = True):
+    def __do_execute(_sql: str):
+        _result = db_session.execute(text(f"{sql_text}"))
+        if format_result:
+            columns = list(_result.keys())
+            rows = [dict(zip(columns, r)) for r in _result.fetchall()]
+            return rows
+        else:
+            return _result
+
+    if isinstance(sql_text, str):
+        return __do_execute(sql_text)
+    elif isinstance(sql_text, list):
+        results = []
+        for sub_sql_text in sql_text:
+            result = __do_execute(sub_sql_text)
+            results.append(result)
+            return results
+    else:
+        return []

{agentic_kit_common-0.0.3 → agentic_kit_common-0.0.17}/agentic_kit_common/orm/manager.py

@@ -14,8 +14,7 @@ class BaseOrmManager(object):
     def get_by_id(cls, obj_id, close_session_after_curd=False):
         with get_db_session() as db:
             query = db.query(cls._model_cls) \
-                .filter(cls._model_cls.id == obj_id) \
-                .filter(cls._model_cls.active == True)
+                .filter(cls._model_cls.id == obj_id)
 
             if hasattr(cls._model_cls, 'active'):
                 query = query.filter(cls._model_cls.active == 1)
@@ -51,7 +50,7 @@ class BaseOrmManager(object):
                 return res
 
     @classmethod
-    def get_list(cls, paginate=False, close_session_after_curd=False, **kwargs):
+    def get_list(cls, paginate=False, close_session_after_curd=False, render: bool = True, **kwargs):
         with get_db_session() as db:
             query = db.query(cls._model_cls)
             # """分页查询示例"""
@@ -92,6 +91,8 @@ class BaseOrmManager(object):
 
                 # 查询记录
                 result = query.all()
+                if render:
+                    result = [cls.render(item) for item in result]
                 pagination = {
                     'total': total,
                     'page': page,
@@ -102,6 +103,8 @@ class BaseOrmManager(object):
                 # return pagination
             else:
                 res = query.all()
+                if render:
+                    res = [cls.render(item) for item in res]
                 # return res
 
             if close_session_after_curd:
@@ -124,9 +127,10 @@ class BaseOrmManager(object):
     @classmethod
     def soft_delete_obj(cls, obj):
         """软删除obj信息"""
-        cls.update_obj(obj, **{
-            'active': False
-        })
+        if hasattr(cls._model_cls, 'active'):
+            cls.update_obj(obj, **{
+                'active': False
+            })
         return obj
 
     @classmethod