sycommon-python-lib 0.2.0b20__tar.gz → 0.2.0b22__tar.gz

{sycommon_python_lib-0.2.0b20 → sycommon_python_lib-0.2.0b22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.0b20
+Version: 0.2.0b22
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -10,6 +10,7 @@ Requires-Dist: aiomysql>=0.3.2
 Requires-Dist: anyio>=4.12.1
 Requires-Dist: decorator>=5.2.1
 Requires-Dist: deepagents>=0.4.5
+Requires-Dist: elasticsearch>=9.3.0
 Requires-Dist: fastapi>=0.133.1
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: kafka-python>=2.3.0
@@ -26,6 +27,7 @@ Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: python-multipart>=0.0.22
 Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: redis>=7.3.0
 Requires-Dist: sentry-sdk[fastapi]>=2.53.0
 Requires-Dist: sqlalchemy[asyncio]>=2.0.47
 Requires-Dist: starlette>=0.52.1

{sycommon_python_lib-0.2.0b20 → sycommon_python_lib-0.2.0b22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.0b20"
+version = "0.2.0b22"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -11,6 +11,7 @@ dependencies = [
     "anyio>=4.12.1",
     "decorator>=5.2.1",
     "deepagents>=0.4.5",
+    "elasticsearch>=9.3.0",
     "fastapi>=0.133.1",
     "jinja2>=3.1.6",
     "kafka-python>=2.3.0",
@@ -27,6 +28,7 @@ dependencies = [
     "python-dotenv>=1.2.1",
     "python-multipart>=0.0.22",
     "pyyaml>=6.0.3",
+    "redis>=7.3.0",
     "sentry-sdk[fastapi]>=2.53.0",
     "sqlalchemy[asyncio]>=2.0.47",
     "starlette>=0.52.1",

{sycommon_python_lib-0.2.0b20 → sycommon_python_lib-0.2.0b22}/src/sycommon/config/Config.py

@@ -22,6 +22,7 @@ class Config(metaclass=SingletonMeta):
         self.reranker_configs = []
         self.sentry_configs = []
         self.langfuse_configs = []
+        self.elasticsearch_configs = []
         self._process_config()
 
     def get_llm_config(self, model_name):
@@ -54,6 +55,12 @@ class Config(metaclass=SingletonMeta):
                 return langfuse
         raise ValueError(f"No configuration found for server: {name}")
 
+    def get_elasticsearch_config(self, name="default"):
+        for es in self.elasticsearch_configs:
+            if es.get('name') == name:
+                return es
+        raise ValueError(f"No configuration found for elasticsearch: {name}")
+
     def _process_config(self):
         llm_config_list = self.config.get('LLMConfig', [])
         for llm_config in llm_config_list:
@@ -92,6 +99,16 @@ class Config(metaclass=SingletonMeta):
             except ValueError as e:
                 print(f"Invalid Sentry configuration: {e}")
 
+        elasticsearch_config_list = self.config.get('ElasticsearchConfig', [])
+        for es_config in elasticsearch_config_list:
+            try:
+                from sycommon.config.ElasticsearchConfig import ElasticsearchConfig
+                validated_config = ElasticsearchConfig(**es_config)
+                self.elasticsearch_configs.append(
+                    validated_config.model_dump())
+            except ValueError as e:
+                print(f"Invalid Elasticsearch configuration: {e}")
+
     def set_attr(self, share_configs: dict):
         self.config = {**self.config, **
                        share_configs.get('llm', {}), **share_configs}

sycommon_python_lib-0.2.0b22/src/sycommon/config/ElasticsearchConfig.py

@@ -0,0 +1,65 @@
+from pydantic import BaseModel, Field
+from typing import List
+import re
+
+
+class ElasticsearchConfig(BaseModel):
+    """Elasticsearch 配置"""
+    name: str = Field(default="default", description="配置名称")
+    uris: str = Field(..., description="ES节点地址，多个用英文逗号分隔")
+    username: str = Field(default="elastic", description="用户名")
+    password: str = Field(..., description="密码")
+
+    @property
+    def uri_list(self) -> List[str]:
+        """获取 URI 列表，自动补全 scheme 和 port"""
+        uris = [uri.strip() for uri in self.uris.split(",") if uri.strip()]
+        normalized = []
+        for uri in uris:
+            normalized.append(self._normalize_uri(uri))
+        return normalized
+
+    @staticmethod
+    def _normalize_uri(uri: str) -> str:
+        """
+        标准化 ES URI，确保包含 scheme、host 和 port
+
+        Examples:
+            localhost:9200 -> http://localhost:9200
+            localhost -> http://localhost:9200
+            10.10.6.202:9200 -> http://10.10.6.202:9200
+            http://localhost:9200 -> http://localhost:9200
+            https://localhost:9200 -> https://localhost:9200
+        """
+        uri = uri.strip()
+
+        # 已有 scheme
+        if uri.startswith("http://") or uri.startswith("https://"):
+            # 检查是否有 port
+            # http://localhost -> http://localhost:9200
+            parsed = re.match(r'(https?://)([^:/]+)(:\d+)?(.*)$', uri)
+            if parsed:
+                scheme = parsed.group(1)
+                host = parsed.group(2)
+                port = parsed.group(3)
+                if not port:
+                    port = ":9200"
+                return f"{scheme}{host}{port}"
+            return uri
+
+        # 没有 scheme，默认 http
+        # localhost:9200 -> http://localhost:9200
+        # localhost -> http://localhost:9200
+        if ":" in uri:
+            # 有端口
+            return f"http://{uri}"
+        else:
+            # 没有端口，默认 9200
+            return f"http://{uri}:9200"
+
+    @classmethod
+    def from_config(cls, name: str = "default"):
+        """从配置文件获取 ES 配置"""
+        from sycommon.config.Config import Config
+        es_config = Config().get_elasticsearch_config(name)
+        return cls(**es_config)

sycommon_python_lib-0.2.0b22/src/sycommon/config/RedisConfig.py

@@ -0,0 +1,150 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List
+import re
+
+
+class RedisPoolConfig(BaseModel):
+    """Redis 连接池配置（对应 Spring Lettuce Pool）"""
+    max_active: int = Field(default=50, description="最大活跃连接数")
+    max_idle: int = Field(default=10, description="最大空闲连接数")
+    max_wait: int = Field(default=30, description="最大等待时间（秒）")
+    min_idle: int = Field(default=1, description="最小空闲连接数")
+
+
+class RedisSentinelConfig(BaseModel):
+    """Redis Sentinel 配置"""
+    master: str = Field(..., description="主节点名称")
+    nodes: List[str] = Field(default_factory=list, description="Sentinel 节点列表")
+    topology_refresh_interval: Optional[int] = Field(default=None, description="拓扑刷新间隔（秒）")
+
+    @classmethod
+    def from_dict(cls, sentinel: dict) -> "RedisSentinelConfig":
+        """从字典解析 Sentinel 配置"""
+        nodes_str = sentinel.get("nodes", "")
+        # 解析节点列表，支持逗号分隔
+        nodes = []
+        if nodes_str:
+            nodes = [n.strip() for n in nodes_str.split(",") if n.strip()]
+
+        # 解析拓扑刷新间隔
+        topology_refresh_interval = None
+        topology_refresh = sentinel.get("topologyRefresh", {})
+        if topology_refresh:
+            interval = topology_refresh.get("interval")
+            if interval:
+                topology_refresh_interval = RedisConfig._parse_duration(interval)
+
+        return cls(
+            master=sentinel.get("master", "mymaster"),
+            nodes=nodes,
+            topology_refresh_interval=topology_refresh_interval
+        )
+
+
+class RedisConfig(BaseModel):
+    """Redis 配置（对应 Spring Redis YAML 格式）"""
+    host: str = Field(default="localhost", description="Redis 主机地址")
+    port: int = Field(default=6379, description="Redis 端口")
+    password: Optional[str] = Field(default=None, description="密码")
+    database: int = Field(default=0, description="数据库索引")
+    timeout: int = Field(default=60, description="超时时间（秒）")
+    pool: Optional[RedisPoolConfig] = Field(default=None, description="连接池配置")
+    sentinel: Optional[RedisSentinelConfig] = Field(default=None, description="Sentinel 配置")
+
+    @classmethod
+    def from_spring_yaml(cls, config: dict) -> "RedisConfig":
+        """
+        从 Spring Redis YAML 格式解析配置
+
+        支持两种模式：
+        1. 单机模式：配置 host/port
+        2. Sentinel 模式：配置 sentinel.master/nodes
+
+        Args:
+            config: Spring Redis 配置字典
+
+        Returns:
+            RedisConfig 实例
+        """
+        # 获取 spring.redis 配置
+        spring_config = config.get("spring", {})
+        redis_config = spring_config.get("redis", {})
+
+        if not redis_config:
+            raise ValueError("未找到 Spring Redis 配置")
+
+        # 解析超时时间（支持 "60s" 格式）
+        timeout = redis_config.get("timeout", 60)
+        if isinstance(timeout, str):
+            timeout = cls._parse_duration(timeout)
+
+        # 解析连接池配置
+        pool_config = None
+        lettuce = redis_config.get("lettuce", {})
+        pool = lettuce.get("pool", {})
+        if pool:
+            max_wait = pool.get("max-wait", 30)
+            if isinstance(max_wait, str):
+                max_wait = cls._parse_duration(max_wait)
+
+            pool_config = RedisPoolConfig(
+                max_active=pool.get("max-active", 50),
+                max_idle=pool.get("max-idle", 10),
+                max_wait=max_wait,
+                min_idle=pool.get("min-idle", 1)
+            )
+
+        # 解析 Sentinel 配置
+        sentinel_config = None
+        sentinel = redis_config.get("sentinel", {})
+        if sentinel and sentinel.get("master") and sentinel.get("nodes"):
+            sentinel_config = RedisSentinelConfig.from_dict(sentinel)
+
+        return cls(
+            host=redis_config.get("host", "localhost"),
+            port=redis_config.get("port", 6379),
+            password=redis_config.get("password"),
+            database=redis_config.get("database", 0),
+            timeout=timeout,
+            pool=pool_config,
+            sentinel=sentinel_config
+        )
+
+    @staticmethod
+    def _parse_duration(duration: str) -> int:
+        """
+        解析持续时间字符串为秒数
+
+        Args:
+            duration: 持续时间字符串，如 "60s", "30s", "1m"
+
+        Returns:
+            秒数
+        """
+        if not duration:
+            return 60
+
+        if isinstance(duration, (int, float)):
+            return int(duration)
+
+        # 匹配数字和单位
+        match = re.match(r"(\d+)([smh]?)", str(duration).strip())
+        if not match:
+            return 60
+
+        value = int(match.group(1))
+        unit = match.group(2) or "s"
+
+        if unit == "s":
+            return value
+        elif unit == "m":
+            return value * 60
+        elif unit == "h":
+            return value * 3600
+
+        return value
+
+    @property
+    def is_sentinel_mode(self) -> bool:
+        """是否为 Sentinel 模式"""
+        return self.sentinel is not None and len(self.sentinel.nodes) > 0

sycommon_python_lib-0.2.0b22/src/sycommon/database/elasticsearch_service.py

@@ -0,0 +1,104 @@
+"""
+Elasticsearch 异步服务
+管理 ES 客户端连接，供其他业务服务使用
+"""
+import logging
+from typing import Optional, Any, List
+
+from sycommon.config.Config import SingletonMeta
+
+
+class ElasticsearchService(metaclass=SingletonMeta):
+    """Elasticsearch 基础服务（单例）"""
+    _client: Optional[Any] = None
+    _initialized: bool = False
+
+    def __init__(self):
+        pass
+
+    @classmethod
+    def setup(cls, config: Optional[dict] = None):
+        """
+        ES 服务初始化函数（用于 Services.plugins 传入）
+
+        用法：
+            Services.plugins(
+                app,
+                elasticsearch_service=ElasticsearchService.setup
+            )
+        """
+        cls.init(config)
+
+    @classmethod
+    def init(cls, config: Optional[dict] = None):
+        """
+        初始化 ES 连接
+
+        Args:
+            config: 配置字典，包含 ElasticsearchConfig 配置
+        """
+        if cls._initialized:
+            return
+
+        try:
+            from sycommon.config.ElasticsearchConfig import ElasticsearchConfig
+            from sycommon.config.Config import Config
+
+            # 获取 ES 配置
+            es_configs = Config().config.get('ElasticsearchConfig', [])
+            if not es_configs:
+                logging.info("未配置 ElasticsearchConfig，ES 服务将禁用")
+                return
+
+            # 使用第一个配置
+            es_config = ElasticsearchConfig(**es_configs[0])
+
+            # 导入 ES 客户端
+            try:
+                from elasticsearch import AsyncElasticsearch
+            except ImportError:
+                logging.warning("未安装 elasticsearch 包，请执行: pip install elasticsearch")
+                return
+
+            # 创建异步客户端
+            cls._client = AsyncElasticsearch(
+                hosts=es_config.uri_list,
+                basic_auth=(es_config.username, es_config.password),
+                verify_certs=False,
+                retry_on_timeout=True,
+                max_retries=3
+            )
+
+            cls._initialized = True
+            logging.info(f"ElasticsearchService 初始化成功，ES 地址: {es_config.uris}")
+
+        except Exception as e:
+            logging.error(f"ElasticsearchService 初始化失败: {e}", exc_info=True)
+
+    @classmethod
+    def get_client(cls) -> Optional[Any]:
+        """
+        获取 ES 客户端
+
+        Returns:
+            AsyncElasticsearch 客户端实例，未初始化返回 None
+        """
+        return cls._client
+
+    @classmethod
+    def is_initialized(cls) -> bool:
+        """检查是否已初始化"""
+        return cls._initialized
+
+    @classmethod
+    async def close(cls):
+        """关闭 ES 连接"""
+        if cls._client:
+            try:
+                await cls._client.close()
+                logging.info("ElasticsearchService ES 连接已关闭")
+            except Exception as e:
+                logging.error(f"关闭 ES 连接失败: {e}")
+            finally:
+                cls._client = None
+                cls._initialized = False