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

fiuai_sdk_python/resp.py

@@ -6,6 +6,7 @@
 # Copyright (c) 2025 FiuAI
 
 import logging
+from httpx import Response
 from typing import List, Dict, Any, Optional, Union
 from pydantic import BaseModel, Field
 
@@ -30,7 +31,41 @@ class ApiResponse(BaseModel):
         return self.http_success and self.api_success
 
 
-def parse_response(response) -> ApiResponse:
+def _get_response_body_preview(response: Response, max_chars: int = 300) -> str:
+    """
+    安全读取响应体前若干字符，用于错误信息预览。兼容编码问题及中文。
+    """
+    try:
+        raw = response.content
+        if not raw:
+            return ""
+        text = raw.decode("utf-8", errors="replace")
+        text = text.strip()
+        if len(text) > max_chars:
+            text = text[:max_chars] + "..."
+        return text
+    except Exception:
+        return ""
+
+
+def _get_response_body_for_log(response: Response, max_chars: int = 2000) -> str:
+    """
+    安全读取完整响应体用于日志，避免编码异常，支持中文。
+    """
+    try:
+        raw = response.content
+        if not raw:
+            return "(empty)"
+        text = raw.decode("utf-8", errors="replace")
+        text = text.strip()
+        if len(text) > max_chars:
+            text = text[:max_chars] + "...(truncated)"
+        return text
+    except Exception as ex:
+        return f"(decode error: {ex})"
+
+
+def parse_response(response: Response) -> ApiResponse:
     """
     解析HTTP响应，返回结构化的API响应
     
@@ -67,12 +102,25 @@ def parse_response(response) -> ApiResponse:
     try:
         response_data = response.json()
     except Exception as e:
+        # 安全读取响应体，兼容非 UTF-8 及中文等，便于日志和错误信息完整
+        raw_preview = _get_response_body_preview(response, max_chars=300)
+        err_msg = f"Invalid JSON response (status={response.status_code}): {e}"
+        if raw_preview:
+            err_msg += f"; body preview: {raw_preview}"
+        else:
+            err_msg += "; response body empty (e.g. gateway/upstream error)"
+        logger.error(
+            "parse_response json failed, status=%s, error=%s, body=%s",
+            response.status_code,
+            str(e),
+            _get_response_body_for_log(response),
+        )
         return ApiResponse(
             http_success=True,
             api_success=False,
             status_code=response.status_code,
-            error_message=[f"Invalid JSON response: {e}"],
-            error_code=["API_INVALID_JSON"]
+            error_message=[err_msg],
+            error_code=["API_INVALID_JSON"],
         )
     
     # 检查API业务是否成功

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiuai_sdk_python
-Version: 0.7.0
+Version: 0.7.2
 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.2.dist-info}/RECORD

@@ -11,7 +11,7 @@ fiuai_sdk_python/error.py,sha256=YYsqP39vY8N7wWD4ervsx7ngcdXIMR59Wc4A4h4Rb-k,235
 fiuai_sdk_python/item.py,sha256=RPvUYaJDWTyUBdqdrPKkgFR4txYXQVqoDPPhv0iBUac,1434
 fiuai_sdk_python/perm.py,sha256=BEQjgJeW4JqG8mhNndRd8TBipnjCh2kBEMWEYXQgths,150
 fiuai_sdk_python/profile.py,sha256=hcbJIYHAR-OEkFDRp-o1c91aVDinIwNsv7oAspFcxxQ,5526
-fiuai_sdk_python/resp.py,sha256=4twCxmwqe2e1vlhfFnu-5_FR8PwQiveB9njY3exaQ88,10183
+fiuai_sdk_python/resp.py,sha256=UiagvtsX8SQRRA226dCS9ggQ7tKWa1SLE4DaqCXGIKc,11861
 fiuai_sdk_python/setup.py,sha256=ER0IPAouHhrVSzG0Iu87Ky0R5c4kCgOF77kRAOO-1MI,8025
 fiuai_sdk_python/type.py,sha256=vinZKflNvmQNhqO5mDARAE6O133k0LiR1s1ZvexN_q4,28940
 fiuai_sdk_python/util.py,sha256=x3TkNsC8_nzA-8x6ndIGrIpE9sRKpn3vlxnj2Hqpxwo,2326
@@ -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.2.dist-info/METADATA,sha256=875jpAqWZXx7CphAj7wDdLjgrfHX1YOvu9vj939rzVM,1523
+fiuai_sdk_python-0.7.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fiuai_sdk_python-0.7.2.dist-info/licenses/LICENSE,sha256=PFMF0dFErrBFqU-rryEby0yW8GBagYqrdbyZQHMUCJg,1062
+fiuai_sdk_python-0.7.2.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()
-