sycommon-python-lib 0.1.57b1__py3-none-any.whl → 0.1.57b4__py3-none-any.whl

sycommon/llm/embedding.py

@@ -1,8 +1,7 @@
 import asyncio
-import json
 import aiohttp
-from typing import Union, List, Optional
-
+import atexit
+from typing import Union, List, Optional, Dict
 from sycommon.config.Config import SingletonMeta
 from sycommon.config.EmbeddingConfig import EmbeddingConfig
 from sycommon.config.RerankerConfig import RerankerConfig
@@ -23,12 +22,113 @@ class Embedding(metaclass=SingletonMeta):
         self.reranker_base_url = RerankerConfig.from_config(
             self.default_reranker_model).baseUrl
 
+        # [修复] 缓存配置URL，避免高并发下重复读取配置文件
+        self._embedding_url_cache: Dict[str, str] = {
+            self.default_embedding_model: self.embeddings_base_url
+        }
+        self._reranker_url_cache: Dict[str, str] = {
+            self.default_reranker_model: self.reranker_base_url
+        }
+
+        # [修复] 缓存模型的向量维度，用于生成兜底零向量
+        self._model_dim_cache: Dict[str, int] = {}
+
         # 并发信号量
         self.semaphore = asyncio.Semaphore(self.max_concurrency)
-        # 全局默认超时：永不超时（None）
         self.default_timeout = aiohttp.ClientTimeout(total=None)
 
-    async def _get_embeddings_http_async(
+        # 核心优化：创建全局可复用的ClientSession（连接池复用）
+        self.session = None
+        # 重试配置（可根据需要调整）
+        self.max_retry_attempts = 3  # 最大重试次数
+        self.retry_wait_base = 0.5   # 基础等待时间（秒）
+
+        # [修复] 注册退出钩子，确保程序结束时关闭连接池
+        atexit.register(self._sync_close_session)
+
+    async def init_session(self):
+        """初始化全局ClientSession（仅创建一次）"""
+        if self.session is None or self.session.closed:
+            # 配置连接池参数，适配高并发
+            connector = aiohttp.TCPConnector(
+                limit=self.max_concurrency * 2,  # 连接池最大连接数（建议是并发数的2倍）
+                limit_per_host=self.max_concurrency,  # 每个域名的最大连接数
+                ttl_dns_cache=300,  # DNS缓存时间
+                enable_cleanup_closed=True  # 自动清理关闭的连接
+            )
+            self.session = aiohttp.ClientSession(
+                connector=connector,
+                timeout=self.default_timeout
+            )
+
+    async def close_session(self):
+        """关闭全局Session（程序退出时调用）"""
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+    def _sync_close_session(self):
+        """同步关闭Session的封装，供atexit调用"""
+        # 注意：atexit在主线程运行，如果当前没有事件循环，这个操作可能会受限
+        # 但它能捕获大多数正常退出的场景。对于asyncio程序，建议显式调用cleanup
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # 如果loop还在跑，创建一个任务去关闭
+                loop.create_task(self.close_session())
+            else:
+                # 如果loop已经停止，尝试运行一次
+                loop.run_until_complete(self.close_session())
+        except Exception:
+            # 静默处理清理失败，避免退出报错
+            pass
+
+    async def _retry_request(self, func, *args, **kwargs):
+        """
+        原生异步重试封装函数
+        Args:
+            func: 待重试的异步函数
+            *args: 函数参数
+            **kwargs: 函数关键字参数
+        Returns:
+            函数执行结果，重试失败返回None
+        """
+        attempt = 0
+        while attempt < self.max_retry_attempts:
+            try:
+                return await func(*args, **kwargs)
+            except (aiohttp.ClientConnectionResetError, asyncio.TimeoutError, aiohttp.ClientError) as e:
+                attempt += 1
+                if attempt >= self.max_retry_attempts:
+                    SYLogger.error(
+                        f"Request failed after {attempt} retries: {str(e)}")
+                    return None
+                # 指数退避等待：0.5s → 1s → 2s（最大不超过5s）
+                wait_time = min(self.retry_wait_base * (2 ** (attempt - 1)), 5)
+                SYLogger.warning(
+                    f"Retry {func.__name__} (attempt {attempt}/{self.max_retry_attempts}): {str(e)}, wait {wait_time}s")
+                await asyncio.sleep(wait_time)
+            except Exception as e:
+                # 非重试类异常直接返回None
+                SYLogger.error(
+                    f"Non-retryable error in {func.__name__}: {str(e)}")
+                return None
+        return None
+
+    def _get_embedding_url(self, model: str) -> str:
+        """获取Embedding URL（带缓存）"""
+        if model not in self._embedding_url_cache:
+            self._embedding_url_cache[model] = EmbeddingConfig.from_config(
+                model).baseUrl
+        return self._embedding_url_cache[model]
+
+    def _get_reranker_url(self, model: str) -> str:
+        """获取Reranker URL（带缓存）"""
+        if model not in self._reranker_url_cache:
+            self._reranker_url_cache[model] = RerankerConfig.from_config(
+                model).baseUrl
+        return self._reranker_url_cache[model]
+
+    async def _get_embeddings_http_core(
         self,
         input: Union[str, List[str]],
         encoding_format: str = None,
@@ -36,13 +136,14 @@ class Embedding(metaclass=SingletonMeta):
         timeout: aiohttp.ClientTimeout = None,
         **kwargs
     ):
+        """embedding请求核心逻辑（剥离重试，供重试封装调用）"""
+        await self.init_session()  # 确保Session已初始化
         async with self.semaphore:
-            # 优先使用传入的超时，无则用全局默认
             request_timeout = timeout or self.default_timeout
-
-            # 优先使用传入的模型名，无则用默认值
             target_model = model or self.default_embedding_model
-            target_base_url = EmbeddingConfig.from_config(target_model).baseUrl
+
+            # [修复] 使用缓存获取URL
+            target_base_url = self._get_embedding_url(target_model)
             url = f"{target_base_url}/v1/embeddings"
 
             request_body = {
@@ -52,25 +153,33 @@ class Embedding(metaclass=SingletonMeta):
             }
             request_body.update(kwargs)
 
-            try:
-                async with aiohttp.ClientSession(timeout=request_timeout) as session:
-                    async with session.post(url, json=request_body) as response:
-                        if response.status != 200:
-                            error_detail = await response.text()
-                            SYLogger.error(
-                                f"Embedding request failed (model: {target_model}): {error_detail}")
-                            return None
-                        return await response.json()
-            except asyncio.TimeoutError:
-                SYLogger.error(
-                    f"Embedding request timeout (model: {target_model})")
-                return None
-            except Exception as e:
-                SYLogger.error(
-                    f"Embedding request unexpected error (model: {target_model}): {str(e)}")
-                return None
+            # 复用全局Session
+            async with self.session.post(
+                url,
+                json=request_body,
+                timeout=request_timeout
+            ) as response:
+                if response.status != 200:
+                    error_detail = await response.text()
+                    SYLogger.error(
+                        f"Embedding request failed (model: {target_model}): {error_detail}")
+                    return None
+                return await response.json()
 
-    async def _get_reranker_http_async(
+    async def _get_embeddings_http_async(
+        self,
+        input: Union[str, List[str]],
+        encoding_format: str = None,
+        model: str = None,
+        timeout: aiohttp.ClientTimeout = None, ** kwargs
+    ):
+        """对外暴露的embedding请求方法（包含重试）"""
+        return await self._retry_request(
+            self._get_embeddings_http_core,
+            input, encoding_format, model, timeout, ** kwargs
+        )
+
+    async def _get_reranker_http_core(
         self,
         documents: List[str],
         query: str,
@@ -79,16 +188,16 @@ class Embedding(metaclass=SingletonMeta):
         max_chunks_per_doc: Optional[int] = None,
         return_documents: Optional[bool] = True,
         return_len: Optional[bool] = True,
-        timeout: aiohttp.ClientTimeout = None,
-        **kwargs
+        timeout: aiohttp.ClientTimeout = None, ** kwargs
     ):
+        """reranker请求核心逻辑（剥离重试，供重试封装调用）"""
+        await self.init_session()  # 确保Session已初始化
         async with self.semaphore:
-            # 优先使用传入的超时，无则用全局默认
             request_timeout = timeout or self.default_timeout
-
-            # 优先使用传入的模型名，无则用默认值
             target_model = model or self.default_reranker_model
-            target_base_url = RerankerConfig.from_config(target_model).baseUrl
+
+            # [修复] 使用缓存获取URL
+            target_base_url = self._get_reranker_url(target_model)
             url = f"{target_base_url}/v1/rerank"
 
             request_body = {
@@ -99,27 +208,39 @@ class Embedding(metaclass=SingletonMeta):
                 "max_chunks_per_doc": max_chunks_per_doc,
                 "return_documents": return_documents,
                 "return_len": return_len,
-                "kwargs": json.dumps(kwargs),
             }
             request_body.update(kwargs)
 
-            try:
-                async with aiohttp.ClientSession(timeout=request_timeout) as session:
-                    async with session.post(url, json=request_body) as response:
-                        if response.status != 200:
-                            error_detail = await response.text()
-                            SYLogger.error(
-                                f"Rerank request failed (model: {target_model}): {error_detail}")
-                            return None
-                        return await response.json()
-            except asyncio.TimeoutError:
-                SYLogger.error(
-                    f"Rerank request timeout (model: {target_model})")
-                return None
-            except Exception as e:
-                SYLogger.error(
-                    f"Rerank request unexpected error (model: {target_model}): {str(e)}")
-                return None
+            # 复用全局Session
+            async with self.session.post(
+                url,
+                json=request_body,
+                timeout=request_timeout
+            ) as response:
+                if response.status != 200:
+                    error_detail = await response.text()
+                    SYLogger.error(
+                        f"Rerank request failed (model: {target_model}): {error_detail}")
+                    return None
+                return await response.json()
+
+    async def _get_reranker_http_async(
+        self,
+        documents: List[str],
+        query: str,
+        top_n: Optional[int] = None,
+        model: str = None,
+        max_chunks_per_doc: Optional[int] = None,
+        return_documents: Optional[bool] = True,
+        return_len: Optional[bool] = True,
+        timeout: aiohttp.ClientTimeout = None, ** kwargs
+    ):
+        """对外暴露的reranker请求方法（包含重试）"""
+        return await self._retry_request(
+            self._get_reranker_http_core,
+            documents, query, top_n, model, max_chunks_per_doc,
+            return_documents, return_len, timeout, **kwargs
+        )
 
     async def get_embeddings(
         self,
@@ -145,28 +266,70 @@ class Embedding(metaclass=SingletonMeta):
                 SYLogger.warning(
                     f"Invalid timeout type: {type(timeout)}, must be int/float, use default timeout")
 
+        actual_model = model or self.default_embedding_model
+
         SYLogger.info(
-            f"Requesting embeddings for corpus: {corpus} (model: {model or self.default_embedding_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
-
-        # 给每个异步任务传入模型名称和超时配置
-        tasks = [self._get_embeddings_http_async(
-            text, model=model, timeout=request_timeout) for text in corpus]
-        results = await asyncio.gather(*tasks)
-
-        vectors = []
-        for result in results:
-            if result is None:
-                zero_vector = [0.0] * 1024
-                vectors.append(zero_vector)
-                SYLogger.warning(
-                    f"Embedding request failed, append zero vector (1024D)")
-                continue
-            for item in result["data"]:
-                vectors.append(item["embedding"])
+            f"Requesting embeddings for corpus: {len(corpus)} items (model: {actual_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
+
+        all_vectors = []
+
+        # [修复] 增加 Chunk 处理逻辑，防止 corpus 过大导致内存溢出或协程过多
+        # 每次最多处理 max_concurrency * 2 个请求，避免一次性创建几十万个协程
+        batch_size = self.max_concurrency * 2
+
+        for i in range(0, len(corpus), batch_size):
+            batch_texts = corpus[i: i + batch_size]
+
+            # 给每个异步任务传入模型名称和超时配置
+            tasks = [self._get_embeddings_http_async(
+                text, model=model, timeout=request_timeout) for text in batch_texts]
+            results = await asyncio.gather(*tasks)
+
+            for result in results:
+                if result is None:
+                    # [修复] 尝试获取真实维度或使用配置兜底，不再硬编码 1024
+                    dim = self._model_dim_cache.get(actual_model)
+
+                    # 如果缓存中没有维度，尝试从配置对象获取（假设Config类有dimension属性）
+                    if dim is None:
+                        try:
+                            config = EmbeddingConfig.from_config(actual_model)
+                            if hasattr(config, 'dimension'):
+                                dim = config.dimension
+                            else:
+                                # 最后的兜底：如果配置也没有，必须有一个默认值防止崩溃
+                                # bge-large 通常是 1024
+                                dim = 1024
+                                SYLogger.warning(
+                                    f"Cannot get dimension from config for {actual_model}, use default 1024")
+                        except Exception:
+                            dim = 1024
+
+                    zero_vector = [0.0] * dim
+                    all_vectors.append(zero_vector)
+                    SYLogger.warning(
+                        f"Embedding request failed, append zero vector ({dim}D) for model {actual_model}")
+                    continue
+
+                # 从返回结果中提取向量并更新维度缓存
+                # 正常情况下 result["data"] 是一个列表
+                try:
+                    for item in result["data"]:
+                        embedding = item["embedding"]
+                        # [修复] 动态学习并缓存维度
+                        if actual_model not in self._model_dim_cache:
+                            self._model_dim_cache[actual_model] = len(
+                                embedding)
+                        all_vectors.append(embedding)
+                except (KeyError, TypeError) as e:
+                    SYLogger.error(f"Failed to parse embedding result: {e}")
+                    # 解析失败也补零
+                    dim = self._model_dim_cache.get(actual_model, 1024)
+                    all_vectors.append([0.0] * dim)
 
         SYLogger.info(
-            f"Embeddings for corpus: {corpus} created (model: {model or self.default_embedding_model})")
-        return vectors
+            f"Embeddings for corpus created: {len(all_vectors)} vectors (model: {actual_model})")
+        return all_vectors
 
     async def get_reranker(
         self,
@@ -194,11 +357,12 @@ class Embedding(metaclass=SingletonMeta):
                 SYLogger.warning(
                     f"Invalid timeout type: {type(timeout)}, must be int/float, use default timeout")
 
+        actual_model = model or self.default_reranker_model
         SYLogger.info(
-            f"Requesting reranker for top_results: {top_results} (model: {model or self.default_reranker_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
+            f"Requesting reranker for top_results: {top_results} (model: {actual_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
 
         data = await self._get_reranker_http_async(
             top_results, query, model=model, timeout=request_timeout)
         SYLogger.info(
-            f"Reranker for top_results: {top_results} completed (model: {model or self.default_reranker_model})")
+            f"Reranker for top_results completed (model: {actual_model})")
         return data

sycommon/rabbitmq/rabbitmq_client.py

@@ -256,6 +256,9 @@ class RabbitMQClient:
             self._message_handler = handler
 
     async def _process_message_callback(self, message: AbstractIncomingMessage):
+        # 定义标志位，记录我们是否需要重试（即业务是否失败）
+        should_retry = False
+
         try:
             msg_obj: MQMsgModel
             if self.auto_parse_json:
@@ -264,8 +267,9 @@ class RabbitMQClient:
                     msg_obj = MQMsgModel(**body_dict)
                 except json.JSONDecodeError as e:
                     logger.error(f"JSON解析失败: {e}")
-                    await message.nack(requeue=False)
-                    return
+                    # 格式错误，无法处理，直接拒绝不重试
+                    await message.reject(requeue=False)
+                    return  # 这里 return 了，不会走下面的 finally
             else:
                 msg_obj = MQMsgModel(
                     body=message.body.decode("utf-8"),
@@ -279,32 +283,48 @@ class RabbitMQClient:
             if self._message_handler:
                 await self._message_handler(msg_obj, message)
 
-            await message.ack()
+            # 如果正常执行到这里，说明业务成功
+            # await message.ack()
+            # 我们移除这里的 ack，统一交给 finally 处理
 
         except Exception as e:
             logger.error(f"消息处理异常: {e}", exc_info=True)
-            headers = dict(message.headers) if message.headers else {}
-            current_retry = int(headers.get("x-retry-count", 0))
+            # 业务异常，标记需要重试
+            should_retry = True
 
-            if current_retry >= 3:
-                logger.warning(f"重试次数超限，丢弃消息: {message.delivery_tag}")
-                await message.reject(requeue=False)
-            else:
-                headers["x-retry-count"] = current_retry + 1
-                try:
-                    new_msg = Message(
-                        body=message.body,
-                        headers=headers,
-                        content_type=message.content_type,
-                        delivery_mode=message.delivery_mode
-                    )
-                    # 这里的 publish 如果失败，会触发重连机制
-                    # 但注意，当前是在回调线程中，建议做好异常捕获
-                    await self._exchange.publish(new_msg, routing_key=message.routing_key)
-                    await message.ack()
-                except Exception as pub_err:
-                    logger.error(f"重试发布失败: {pub_err}")
+        finally:
+            # 【核心修复】无论发生什么，最后都要给 MQ 一个交待
+            if should_retry:
+                headers = dict(message.headers) if message.headers else {}
+                current_retry = int(headers.get("x-retry-count", 0))
+
+                if current_retry >= 3:
+                    logger.warning(f"重试次数超限，丢弃消息: {message.delivery_tag}")
                     await message.reject(requeue=False)
+                else:
+                    headers["x-retry-count"] = current_retry + 1
+                    try:
+                        new_msg = Message(
+                            body=message.body,
+                            headers=headers,
+                            content_type=message.content_type,
+                            delivery_mode=message.delivery_mode
+                        )
+                        # 发送新消息用于重试
+                        await self._exchange.publish(new_msg, routing_key=message.routing_key)
+
+                        # 【关键】新消息发成功了，现在可以安全地 Ack 掉旧消息了
+                        # 这样旧消息才会从队列中移除，避免死循环
+                        await message.ack()
+
+                    except Exception as pub_err:
+                        logger.error(f"重试发布失败，消息将丢失: {pub_err}")
+                        # 发布失败，无法重试，只能丢弃旧消息（或者 Nack requeue=True）
+                        # 为了防止死循环，这里通常建议 Reject (False) 并配置死信队列
+                        await message.reject(requeue=False)
+            else:
+                # 业务正常执行，直接 Ack
+                await message.ack()
 
     async def start_consuming(self) -> Optional[ConsumerTag]:
         if self._closed:

sycommon/synacos/nacos_client_base.py

@@ -2,6 +2,7 @@ import threading
 import time
 from typing import Optional
 import nacos
+from sycommon.config.Config import Config
 from sycommon.logging.kafka_log import SYLogger
 
 
@@ -94,8 +95,9 @@ class NacosClientBase:
 
         try:
             namespace_id = self.nacos_config['namespaceId']
+            service_name = Config().config.get('Name', '')
             self.nacos_client.list_naming_instance(
-                service_name="",  # 空服务名仅用于验证连接
+                service_name=service_name,
                 namespace_id=namespace_id,
                 group_name="DEFAULT_GROUP",
                 healthy_only=True

{sycommon_python_lib-0.1.57b1.dist-info → sycommon_python_lib-0.1.57b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.57b1
+Version: 0.1.57b4
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.1.57b1.dist-info → sycommon_python_lib-0.1.57b4.dist-info}/RECORD

@@ -19,7 +19,7 @@ sycommon/health/health_check.py,sha256=EhfbhspRpQiKJaxdtE-PzpKQO_ucaFKtQxIm16F5M
 sycommon/health/metrics.py,sha256=fHqO73JuhoZkNPR-xIlxieXiTCvttq-kG-tvxag1s1s,268
 sycommon/health/ping.py,sha256=FTlnIKk5y1mPfS1ZGOeT5IM_2udF5aqVLubEtuBp18M,250
 sycommon/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/llm/embedding.py,sha256=HknwDqXmRQcAZ8-6d8wZ6n7Bv7HtxTajDt1vvzHGeFQ,8411
+sycommon/llm/embedding.py,sha256=rasx8xBOq-mQdWZ5RSzpwjbkAKi7Da-FDWiTm-Ga2Bs,15606
 sycommon/llm/get_llm.py,sha256=C48gt9GCwEpR26M-cUjM74_t-el18ZvlwpGhcQfR3gs,1054
 sycommon/llm/llm_logger.py,sha256=n4UeNy_-g4oHQOsw-VUzF4uo3JVRLtxaMp1FcI8FiEo,5437
 sycommon/llm/llm_tokens.py,sha256=-udDyFcmyzx6UAwIi6_d_wwI5kMd5w0-WcS2soVPQxg,4309
@@ -51,7 +51,7 @@ sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
 sycommon/notice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/notice/uvicorn_monitor.py,sha256=VryQYcAtjijJuGDBimbVurgwxlsLaLtkNnABPDY5Tao,7332
-sycommon/rabbitmq/rabbitmq_client.py,sha256=hAbLOioU_clucJ9xq88Oo-waZOuU0ii4yBVGIjz1nBE,17992
+sycommon/rabbitmq/rabbitmq_client.py,sha256=PaO9shCi665MOuDXhSmRJtOBC-ayo9sD9U3rQq90Rqc,19071
 sycommon/rabbitmq/rabbitmq_pool.py,sha256=BiFQgZPzSAFR-n5XhyIafoeWQXETF_31nFRDhMbe6aU,15577
 sycommon/rabbitmq/rabbitmq_service.py,sha256=XSHo9HuIJ_lq-vizRh4xJVdZr_2zLqeLhot09qb0euA,2025
 sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=IP9TMFeG5LSrwFPEmOy1ce4baPxBUZnWJZR3nN_-XR4,8009
@@ -69,7 +69,7 @@ sycommon/synacos/example.py,sha256=61XL03tU8WTNOo3FUduf93F2fAwah1S0lbH1ufhRhRk,5
 sycommon/synacos/example2.py,sha256=adUaru3Hy482KrOA17DfaC4nwvLj8etIDS_KrWLWmCU,4811
 sycommon/synacos/feign.py,sha256=frB3D5LeFDtT3pJLFOwFzEOrNAJKeQNGk-BzUg9T3WM,8295
 sycommon/synacos/feign_client.py,sha256=ExO7Pd5B3eFKDjXqBRc260K1jkI49IYguLwJJaD2R-o,16166
-sycommon/synacos/nacos_client_base.py,sha256=l5jpall6nEt0Hy07Wk-PVU0VN0BmD_Mmtldmtyvvksg,4526
+sycommon/synacos/nacos_client_base.py,sha256=KZgQAg9Imfr_TfM-4LXdtrnTdJ-beu6bcNJa0c2HauE,4600
 sycommon/synacos/nacos_config_manager.py,sha256=Cff-4gpp0aD7sQVi-nEvDO4BWqK9abEDDDJ9qXKFQgs,4399
 sycommon/synacos/nacos_heartbeat_manager.py,sha256=G80_pOn37WdO_HpYUiAfpwMqAxW0ff0Bnw0NEuge9v0,5568
 sycommon/synacos/nacos_service.py,sha256=BezQ1eDIYwBPE567Po_Qh1Ki_z9WmhZy1J1NiTPbdHY,6118
@@ -82,8 +82,8 @@ sycommon/tools/env.py,sha256=Ah-tBwG2C0_hwLGFebVQgKdWWXCjTzBuF23gCkLHYy4,2437
 sycommon/tools/merge_headers.py,sha256=u9u8_1ZIuGIminWsw45YJ5qnsx9MB-Fot0VPge7itPw,4941
 sycommon/tools/snowflake.py,sha256=xQlYXwYnI85kSJ1rZ89gMVBhzemP03xrMPVX9vVa3MY,9228
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.57b1.dist-info/METADATA,sha256=SSwWUy9hRgJhiqL1ulY91dBhEegshkvsXXLTKxNnXTc,7301
-sycommon_python_lib-0.1.57b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.57b1.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.57b1.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.57b1.dist-info/RECORD,,
+sycommon_python_lib-0.1.57b4.dist-info/METADATA,sha256=DzUZnbSOLPma462MbLY8-WQAaj9wh9BjkB1eSGxzq1A,7301
+sycommon_python_lib-0.1.57b4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.57b4.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.57b4.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.57b4.dist-info/RECORD,,