fiuai-sdk-python 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

{fiuai_sdk_python-0.7.0.dist-info → fiuai_sdk_python-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiuai_sdk_python
-Version: 0.7.0
+Version: 0.7.1
 Summary: FiuAI Python SDK - 企业级AI服务集成开发工具包
 Project-URL: Homepage, https://github.com/fiuai/fiuai-sdk-python
 Project-URL: Documentation, https://github.com/fiuai/fiuai-sdk-python#readme

{fiuai_sdk_python-0.7.0.dist-info → fiuai_sdk_python-0.7.1.dist-info}/RECORD

@@ -25,18 +25,11 @@ fiuai_sdk_python/http/__init__.py,sha256=RMtrf0O-iuAGMIqfpQg6sQHj_O9Lo4Lhn7Kejca
 fiuai_sdk_python/http/client.py,sha256=omcM8R8NGSszZlKBPikZr-NJXHgwpNYu7qDa_9H1Jug,14321
 fiuai_sdk_python/pkg/cache/__init__.py,sha256=7mVRUKkAxCAHIWVZrIslel_kr0S5Je_l0I9Fy_iZjzI,112
 fiuai_sdk_python/pkg/cache/redis_manager.py,sha256=APSRRmsJKRWfDvzIJiwNMtIqjzbheOdULskj5mI55Fk,6114
-fiuai_sdk_python/pkg/db/__init__.py,sha256=IK-zw5tTiSpVMtT3zdVGMaqup08TACIWcEYWpe1htkc,709
-fiuai_sdk_python/pkg/db/config.py,sha256=tId1db3209oZGVQKDwm-cvKu_GCbpbPerR8rgdeD3xE,645
-fiuai_sdk_python/pkg/db/errors.py,sha256=JJwfM_sHXYAOfP5peg9rg8n2BsCMnPXIKVLrOFMPHOs,489
-fiuai_sdk_python/pkg/db/manager.py,sha256=HapTkFOfCzQLCXWBAOlGHsjGCWVBNBLEMCDH7Kty7tI,14855
-fiuai_sdk_python/pkg/db/utils.py,sha256=qqZ14eV7fy9x_mwcEDKJDz1W54xPndpJ1QfM_D0E3FI,2419
-fiuai_sdk_python/pkg/vector/__init__.py,sha256=fvbetFxbHiFeojnTfKT3roA1hOcoNHF_eCRuG6HwMpI,404
-fiuai_sdk_python/pkg/vector/vector.py,sha256=hdwhDSiKp4a7s6dVwFNTRk1BPqhZppywD8LnOudoMdo,28990
 fiuai_sdk_python/utils/__init__.py,sha256=UwwsvqBsaRCHbWdx-wvM48szT3j50h95k9MZdbfawRQ,72
 fiuai_sdk_python/utils/ids.py,sha256=ZDtEqt_Woth8ytPB2tdnnTIv7noWr8XYhSsUvkZ7Hc0,6448
 fiuai_sdk_python/utils/logger.py,sha256=RuKn9TFmV1IfsRTV3ZdtXLZkM44GkHs32ehbJdrdu-8,3657
 fiuai_sdk_python/utils/text.py,sha256=bnob_W0nj_Vj8Hp93B0cYmFOY8IhUWF0C8UedOYCNvs,1667
-fiuai_sdk_python-0.7.0.dist-info/METADATA,sha256=VvQZG__GFesGKAStADnKtBE96LTN2jGaa_vZjZXOCrs,1523
-fiuai_sdk_python-0.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-fiuai_sdk_python-0.7.0.dist-info/licenses/LICENSE,sha256=PFMF0dFErrBFqU-rryEby0yW8GBagYqrdbyZQHMUCJg,1062
-fiuai_sdk_python-0.7.0.dist-info/RECORD,,
+fiuai_sdk_python-0.7.1.dist-info/METADATA,sha256=9zuPOwRytT_wRjNeyutOdtkpDHv7UlOA9FRPTJsDgcc,1523
+fiuai_sdk_python-0.7.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fiuai_sdk_python-0.7.1.dist-info/licenses/LICENSE,sha256=PFMF0dFErrBFqU-rryEby0yW8GBagYqrdbyZQHMUCJg,1062
+fiuai_sdk_python-0.7.1.dist-info/RECORD,,

fiuai_sdk_python/pkg/db/__init__.py

@@ -1,35 +0,0 @@
-# -- coding: utf-8 --
-# Project: fiuai-world
-# Created Date: 2025-01-27
-# Author: liming
-# Email: lmlala@aliyun.com
-# Copyright (c) 2025 FiuAI
-
-from pkg.db.errors import (
-    PostgresError,
-    PostgresConnectionError,
-    PostgresQueryError,
-    PostgresPoolError,
-)
-from pkg.db.config import PostgresConfig
-from pkg.db.manager import (
-    PostgresManager,
-    postgres_manager,
-)
-from pkg.db.utils import (
-    escape_table_name,
-    build_frappe_table_name,
-)
-
-__all__ = [
-    'PostgresManager',
-    'PostgresConfig',
-    'PostgresError',
-    'PostgresConnectionError',
-    'PostgresQueryError',
-    'PostgresPoolError',
-    'postgres_manager',
-    'escape_table_name',
-    'build_frappe_table_name',
-]
-

fiuai_sdk_python/pkg/db/config.py

@@ -1,25 +0,0 @@
-# -- coding: utf-8 --
-# Project: fiuai-world
-# Created Date: 2025-01-27
-# Author: liming
-# Email: lmlala@aliyun.com
-# Copyright (c) 2025 FiuAI
-
-from dataclasses import dataclass
-
-
-@dataclass
-class PostgresConfig:
-    """PostgreSQL 配置"""
-    host: str
-    port: int
-    user: str
-    password: str
-    database: str
-    pool_minconn: int = 1  # 连接池最小连接数
-    pool_maxconn: int = 10  # 连接池最大连接数
-    pool_timeout: int = 30  # 获取连接超时时间（秒）
-    connect_timeout: int = 10  # 连接超时时间（秒）
-    retry_count: int = 3  # 重试次数
-    retry_delay: int = 1  # 重试延迟（秒）
-

fiuai_sdk_python/pkg/db/errors.py

@@ -1,27 +0,0 @@
-# -- coding: utf-8 --
-# Project: fiuai-world
-# Created Date: 2025-01-27
-# Author: liming
-# Email: lmlala@aliyun.com
-# Copyright (c) 2025 FiuAI
-
-
-class PostgresError(Exception):
-    """PostgreSQL 基础错误类"""
-    pass
-
-
-class PostgresConnectionError(PostgresError):
-    """PostgreSQL 连接错误"""
-    pass
-
-
-class PostgresQueryError(PostgresError):
-    """PostgreSQL 查询错误"""
-    pass
-
-
-class PostgresPoolError(PostgresError):
-    """PostgreSQL 连接池错误"""
-    pass
-

fiuai_sdk_python/pkg/db/manager.py

@@ -1,439 +0,0 @@
-# -- coding: utf-8 --
-# Project: fiuai-world
-# Created Date: 2025-01-27
-# Author: liming
-# Email: lmlala@aliyun.com
-# Copyright (c) 2025 FiuAI
-
-import time
-import threading
-from typing import Optional, Dict, Any, List, Union
-from contextlib import contextmanager
-
-import psycopg2
-from psycopg2 import pool
-from psycopg2.extras import RealDictCursor, DictCursor
-
-
-from logging import getLogger
-from .errors import (
-    PostgresError,
-    PostgresConnectionError,
-    PostgresQueryError,
-    PostgresPoolError,
-)
-from .config import PostgresConfig
-
-logger = getLogger(__name__)
-
-
-class PostgresManager:
-    """PostgreSQL 连接池管理器单例类
-    
-    提供连接池管理、重连、重试等稳定性机制
-    提供基础 CRUD 接口
-    """
-    _instance: Optional['PostgresManager'] = None
-    _lock = threading.Lock()
-    _initialized = False
-    
-    def __new__(cls):
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-        return cls._instance
-    
-    def __init__(self):
-        if hasattr(self, '_initialized') and self._initialized:
-            return
-        
-        self._config: Optional[PostgresConfig] = None
-        self._pool: Optional[pool.ThreadedConnectionPool] = None
-        self._is_connected_ref = {'connected': False}
-        self._initialized = True
-    
-    def initialize(self, config: PostgresConfig):
-        """初始化 PostgreSQL 连接池
-        
-        Args:
-            config: PostgreSQL 配置
-            
-        Raises:
-            PostgresPoolError: 初始化失败时抛出
-        """
-        if self._is_connected_ref['connected']:
-            logger.warning("PostgreSQL 已经初始化，跳过重复初始化")
-            return
-        
-        self._config = config
-        
-        try:
-            # 创建连接池
-            self._pool = pool.ThreadedConnectionPool(
-                minconn=config.pool_minconn,
-                maxconn=config.pool_maxconn,
-                host=config.host,
-                port=config.port,
-                user=config.user,
-                password=config.password,
-                database=config.database,
-                connect_timeout=config.connect_timeout,
-            )
-            
-            # 测试连接
-            test_conn = self._pool.getconn()
-            if not test_conn:
-                raise PostgresPoolError("无法从连接池获取连接")
-            
-            # 执行简单查询测试连接
-            with test_conn.cursor() as cursor:
-                cursor.execute("SELECT 1")
-                cursor.fetchone()
-            
-            self._pool.putconn(test_conn)
-            self._is_connected_ref['connected'] = True
-            
-            logger.info(
-                f"PostgreSQL 连接池初始化成功: {config.host}:{config.port}/{config.database}, "
-                f"pool_size={config.pool_maxconn}"
-            )
-            
-        except Exception as e:
-            self._is_connected_ref['connected'] = False
-            if self._pool:
-                try:
-                    self._pool.closeall()
-                except Exception:
-                    pass
-                self._pool = None
-            logger.error(f"PostgreSQL 初始化失败: {str(e)}")
-            raise PostgresPoolError(f"初始化失败: {str(e)}")
-    
-    def _check_connection(self) -> bool:
-        """检查连接是否有效
-        
-        Returns:
-            bool: 连接是否有效
-        """
-        if not self._pool or not self._is_connected_ref.get('connected', False):
-            return False
-        
-        try:
-            conn = self._pool.getconn()
-            if not conn:
-                return False
-            
-            with conn.cursor() as cursor:
-                cursor.execute("SELECT 1")
-                cursor.fetchone()
-            
-            self._pool.putconn(conn)
-            return True
-            
-        except Exception as e:
-            logger.warning(f"连接检查失败: {str(e)}")
-            return False
-    
-    def _reconnect(self) -> bool:
-        """重新连接
-        
-        Returns:
-            bool: 重连是否成功
-        """
-        if not self._config:
-            return False
-        
-        logger.info("尝试重新连接 PostgreSQL...")
-        
-        try:
-            # 关闭旧连接池
-            if self._pool:
-                try:
-                    self._pool.closeall()
-                except Exception:
-                    pass
-                self._pool = None
-            
-            # 重新创建连接池
-            self._pool = pool.ThreadedConnectionPool(
-                minconn=self._config.pool_minconn,
-                maxconn=self._config.pool_maxconn,
-                host=self._config.host,
-                port=self._config.port,
-                user=self._config.user,
-                password=self._config.password,
-                database=self._config.database,
-                connect_timeout=self._config.connect_timeout,
-            )
-            
-            # 测试连接
-            test_conn = self._pool.getconn()
-            if not test_conn:
-                raise PostgresPoolError("无法从连接池获取连接")
-            
-            with test_conn.cursor() as cursor:
-                cursor.execute("SELECT 1")
-                cursor.fetchone()
-            
-            self._pool.putconn(test_conn)
-            self._is_connected_ref['connected'] = True
-            
-            return True
-            
-        except Exception as e:
-            logger.error(f"重连失败: {str(e)}")
-            self._is_connected_ref['connected'] = False
-            return False
-    
-    @contextmanager
-    def _get_connection(self):
-        """获取连接（带重连机制）
-        
-        Yields:
-            connection: PostgreSQL 连接对象
-            
-        Raises:
-            PostgresConnectionError: 获取连接失败时抛出
-        """
-        if not self._is_connected_ref['connected']:
-            if not self._reconnect():
-                raise PostgresConnectionError("无法连接到 PostgreSQL，请检查配置和网络")
-        
-        conn = None
-        try:
-            conn = self._pool.getconn()
-            if not conn:
-                # 尝试重连一次
-                if self._reconnect():
-                    conn = self._pool.getconn()
-                
-                if not conn:
-                    raise PostgresConnectionError("无法从连接池获取连接")
-            
-            yield conn
-            
-        except psycopg2.Error as e:
-            if conn:
-                try:
-                    self._pool.putconn(conn, close=True)
-                except Exception:
-                    pass
-            self._is_connected_ref['connected'] = False
-            raise PostgresConnectionError(f"数据库连接错误: {str(e)}")
-        except Exception as e:
-            if conn:
-                try:
-                    self._pool.putconn(conn)
-                except Exception:
-                    pass
-            raise PostgresConnectionError(f"获取连接时发生错误: {str(e)}")
-        finally:
-            if conn:
-                try:
-                    self._pool.putconn(conn)
-                except Exception:
-                    pass
-    
-    def _execute_with_retry(
-        self,
-        query: str,
-        params: Optional[tuple] = None,
-        retry_count: Optional[int] = None,
-        fetch: bool = True,
-        fetch_one: bool = False,
-        as_dict: bool = False,
-    ) -> Optional[Union[List[Dict[str, Any]], List[tuple], int]]:
-        """执行查询（带重试机制）
-        
-        Args:
-            query: 查询语句
-            params: 查询参数
-            retry_count: 重试次数，None 则使用配置中的值
-            fetch: 是否获取结果
-            fetch_one: 是否只获取一条结果
-            as_dict: 是否返回字典格式
-            
-        Returns:
-            Optional[List[Dict[str, Any]]]: 查询结果，如果 fetch=False 则返回受影响的行数（int）
-            
-        Raises:
-            PostgresQueryError: 执行失败时抛出
-        """
-        if retry_count is None:
-            retry_count = self._config.retry_count if self._config else 3
-        
-        last_error = None
-        for attempt in range(retry_count + 1):
-            try:
-                with self._get_connection() as conn:
-                    cursor_factory = RealDictCursor if as_dict else None
-                    with conn.cursor(cursor_factory=cursor_factory) as cursor:
-                        logger.debug(f"[postgres-sql] {query}")
-                        if params:
-                            logger.debug(f"[postgres-params] {params}")
-                            cursor.execute(query, params)
-                        else:
-                            cursor.execute(query)
-                        
-                        if not fetch:
-                            rowcount = cursor.rowcount
-                            conn.commit()
-                            return rowcount
-                        
-                        if fetch_one:
-                            row = cursor.fetchone()
-                            if as_dict and row:
-                                return [dict(row)]
-                            return [row] if row else []
-                        else:
-                            rows = cursor.fetchall()
-                            if as_dict:
-                                return [dict(row) for row in rows]
-                            return rows
-                
-            except psycopg2.Error as e:
-                last_error = PostgresQueryError(f"数据库查询错误: {str(e)}")
-                # 如果是连接相关错误，尝试重连
-                error_msg = str(e).lower()
-                if "connection" in error_msg or "timeout" in error_msg or "server closed" in error_msg:
-                    self._is_connected_ref['connected'] = False
-                    if attempt < retry_count:
-                        time.sleep(self._config.retry_delay if self._config else 1)
-                        continue
-                
-                if attempt < retry_count:
-                    time.sleep(self._config.retry_delay if self._config else 1)
-                    continue
-                    
-            except Exception as e:
-                last_error = PostgresQueryError(f"执行查询时发生错误: {str(e)}")
-                if attempt < retry_count:
-                    time.sleep(self._config.retry_delay if self._config else 1)
-                    continue
-        
-        raise last_error or PostgresQueryError("查询执行失败")
-    
-    def execute(
-        self,
-        query: str,
-        params: Optional[tuple] = None,
-        retry_count: Optional[int] = None,
-    ) -> int:
-        """执行 SQL 语句（不返回结果）
-        
-        Args:
-            query: SQL 语句
-            params: 查询参数
-            retry_count: 重试次数
-            
-        Returns:
-            int: 受影响的行数
-            
-        Raises:
-            PostgresQueryError: 执行失败时抛出
-        """
-        if not self._is_connected_ref['connected']:
-            raise PostgresQueryError("PostgreSQL 未初始化，请先调用 initialize()")
-        
-        result = self._execute_with_retry(query, params, retry_count, fetch=False)
-        return result if result is not None else 0
-    
-    def query(
-        self,
-        query: str,
-        params: Optional[tuple] = None,
-        retry_count: Optional[int] = None,
-        as_dict: bool = True,
-    ) -> Union[List[Dict[str, Any]], List[tuple]]:
-        """执行查询（返回结果）
-        
-        Args:
-            query: 查询语句
-            params: 查询参数
-            retry_count: 重试次数
-            as_dict: 是否返回字典格式
-            
-        Returns:
-            Union[List[Dict[str, Any]], List[tuple]]: 查询结果列表，as_dict=True 时返回字典列表，否则返回元组列表
-            
-        Raises:
-            PostgresQueryError: 执行失败时抛出
-        """
-        if not self._is_connected_ref['connected']:
-            raise PostgresQueryError("PostgreSQL 未初始化，请先调用 initialize()")
-        
-        result = self._execute_with_retry(query, params, retry_count, fetch=True, as_dict=as_dict)
-        return result or []
-    
-    def query_one(
-        self,
-        query: str,
-        params: Optional[tuple] = None,
-        retry_count: Optional[int] = None,
-        as_dict: bool = True,
-    ) -> Optional[Union[Dict[str, Any], tuple]]:
-        """执行查询（返回单条结果）
-        
-        Args:
-            query: 查询语句
-            params: 查询参数
-            retry_count: 重试次数
-            as_dict: 是否返回字典格式
-            
-        Returns:
-            Optional[Union[Dict[str, Any], tuple]]: 查询结果，as_dict=True 时返回字典，否则返回元组，如果不存在则返回 None
-            
-        Raises:
-            PostgresQueryError: 执行失败时抛出
-        """
-        if not self._is_connected_ref['connected']:
-            raise PostgresQueryError("PostgreSQL 未初始化，请先调用 initialize()")
-        
-        result = self._execute_with_retry(
-            query, params, retry_count, fetch=True, fetch_one=True, as_dict=as_dict
-        )
-        return result[0] if result else None
-    
-    @contextmanager
-    def transaction(self):
-        """事务上下文管理器
-        
-        Yields:
-            connection: PostgreSQL 连接对象
-            
-        Raises:
-            PostgresConnectionError: 获取连接失败时抛出
-        """
-        with self._get_connection() as conn:
-            try:
-                yield conn
-                conn.commit()
-            except Exception as e:
-                conn.rollback()
-                raise PostgresQueryError(f"事务执行失败: {str(e)}")
-    
-    def close(self):
-        """关闭连接池"""
-        if self._pool:
-            try:
-                self._pool.closeall()
-            except Exception as e:
-                logger.warning(f"关闭连接池时发生错误: {str(e)}")
-            finally:
-                self._pool = None
-                self._is_connected_ref['connected'] = False
-                logger.info("PostgreSQL 连接池已关闭")
-    
-    def is_connected(self) -> bool:
-        """检查是否已连接
-        
-        Returns:
-            bool: 是否已连接
-        """
-        return self._is_connected_ref['connected'] and self._check_connection()
-
-
-# 创建全局单例实例
-postgres_manager = PostgresManager()
-

fiuai_sdk_python/pkg/db/utils.py

@@ -1,78 +0,0 @@
-# -- coding: utf-8 --
-# Project: fiuai-world
-# Created Date: 2025-12-06
-# Author: liming
-# Email: lmlala@aliyun.com
-# Copyright (c) 2025 FiuAI
-
-from typing import Any
-
-
-def escape_table_name(table_name: str) -> str:
-    """
-    转义 PostgreSQL 表名，处理大小写和空格
-    
-    PostgreSQL 中，如果表名包含大写字母、空格或特殊字符，需要用双引号包裹
-    Frappe 的表名格式是 tab{doctype}，其中 doctype 可能包含大写字母和空格
-    
-    Args:
-        table_name: 表名（如 "tabContract" 或 "tabA B"）
-        
-    Returns:
-        str: 转义后的表名（如 '"tabContract"' 或 '"tabA B"'）
-        
-    Example:
-        escape_table_name("tabContract")  # 返回: '"tabContract"'
-        escape_table_name("tabA B")       # 返回: '"tabA B"'
-        escape_table_name("tabcontract")  # 返回: '"tabcontract"' (统一加引号，确保安全)
-    """
-    if not table_name:
-        raise ValueError("table_name 不能为空")
-    
-    # 确保是字符串类型
-    if not isinstance(table_name, str):
-        table_name = str(table_name)
-    
-    # 去除首尾空白
-    table_name = table_name.strip()
-    
-    # 如果已经用双引号包裹，先去除
-    if table_name.startswith('"') and table_name.endswith('"'):
-        table_name = table_name[1:-1]
-    
-    # 转义双引号（如果表名中包含双引号）
-    escaped = table_name.replace('"', '""')
-    
-    # 用双引号包裹（PostgreSQL 中双引号用于标识符，可以处理大小写和空格）
-    return f'"{escaped}"'
-
-
-def build_frappe_table_name(doctype: str) -> str:
-    """
-    构建 Frappe 格式的表名并转义
-    
-    Frappe 的表名格式是 tab{doctype}，其中 doctype 可能包含大写字母和空格
-    
-    Args:
-        doctype: 文档类型名称（如 "Contract" 或 "A B"）
-        
-    Returns:
-        str: 转义后的表名（如 '"tabContract"' 或 '"tabA B"'）
-        
-    Example:
-        build_frappe_table_name("Contract")  # 返回: '"tabContract"'
-        build_frappe_table_name("A B")      # 返回: '"tabA B"'
-    """
-    if not doctype:
-        raise ValueError("doctype 不能为空")
-    
-    # 确保是字符串类型
-    if not isinstance(doctype, str):
-        doctype = str(doctype)
-    
-    # 构建 Frappe 表名格式
-    table_name = f"tab{doctype}"
-    
-    # 转义表名
-    return escape_table_name(table_name)
-

fiuai_sdk_python/pkg/vector/__init__.py

@@ -1,23 +0,0 @@
-# -- coding: utf-8 --
-# Project: fiuai-world
-# Created Date: 2025-01-27
-# Author: liming
-# Email: lmlala@aliyun.com
-# Copyright (c) 2025 FiuAI
-
-from .vector import (
-    QdrantManager,
-    QdrantConfig,
-    QdrantError,
-    qdrant_manager,
-    ContextAwareQdrantManager,
-)
-
-__all__ = [
-    'QdrantManager',
-    'QdrantConfig',
-    'QdrantError',
-    'qdrant_manager',
-    'ContextAwareQdrantManager',
-]
-