fiuai-sdk-python 0.7.0__tar.gz → 0.7.1__tar.gz

{fiuai_sdk_python-0.7.0 → fiuai_sdk_python-0.7.1}/PKG-INFO

@@ -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 → fiuai_sdk_python-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fiuai_sdk_python"
-version = "0.7.0"
+version = "0.7.1"
 description = "FiuAI Python SDK - 企业级AI服务集成开发工具包"
 readme = "README.md"
 requires-python = ">=3.12"

fiuai_sdk_python-0.7.0/src/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-0.7.0/src/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-0.7.0/src/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-0.7.0/src/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-0.7.0/src/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-0.7.0/src/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',
-]
-