sycommon-python-lib 0.2.5a13__tar.gz → 0.2.5a14__tar.gz

{sycommon_python_lib-0.2.5a13 → sycommon_python_lib-0.2.5a14}/PKG-INFO

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

{sycommon_python_lib-0.2.5a13 → sycommon_python_lib-0.2.5a14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.5a13"
+version = "0.2.5a14"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.5a13 → sycommon_python_lib-0.2.5a14}/src/sycommon/agent/sandbox/http_sandbox_backend.py

@@ -120,6 +120,10 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         self._nacos_service_name = nacos_service_name
         self._nacos_group = nacos_group
 
+        # 共享异步 HTTP 会话（连接池复用，惰性初始化）
+        self._async_session: Optional[aiohttp.ClientSession] = None
+        self._session_loop_id: Optional[int] = None  # track which loop created the session
+
         # 生成 ID
         self._id = self._base_url.replace(
             "http://", ""
@@ -131,6 +135,55 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             "/", "-"
         )
 
+    async def _get_async_session(self) -> aiohttp.ClientSession:
+        """获取或创建共享的 aiohttp ClientSession（连接池复用）
+
+        Handles the case where the backend was created in a different thread
+        (e.g. via asyncio.to_thread) by detecting loop mismatch and resetting.
+        """
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        # If session was created on a different event loop, discard it
+        if self._async_session is not None and self._session_loop_id != id(current_loop):
+            try:
+                self._async_session.close()
+            except Exception:
+                pass
+            self._async_session = None
+
+        if self._async_session is None or self._async_session.closed:
+            connector = aiohttp.TCPConnector(
+                ssl=_SSL_CONTEXT,
+                limit=10,
+                limit_per_host=10,
+                keepalive_timeout=30,
+                enable_cleanup_closed=True,
+            )
+            self._async_session = aiohttp.ClientSession(connector=connector)
+            self._session_loop_id = id(current_loop)
+        return self._async_session
+
+    async def acleanup(self):
+        """关闭共享的异步 HTTP 会话，释放连接池资源"""
+        if self._async_session and not self._async_session.closed:
+            await self._async_session.close()
+            self._async_session = None
+
+    def cleanup(self):
+        """同步方式关闭共享会话（供非 async 上下文使用）"""
+        if self._async_session and not self._async_session.closed:
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._async_session.close())
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                loop.run_until_complete(self._async_session.close())
+                loop.close()
+            self._async_session = None
+
     @classmethod
     def from_nacos(
         cls,
@@ -361,10 +414,11 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 SYLogger.warning(f"[Sandbox] 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
 
                 if attempt < max_retries - 1:
+                    backoff = 2 ** attempt
                     switched = self._refresh_from_nacos_and_switch_sync()
                     if not switched:
                         import time
-                        time.sleep(1)
+                        time.sleep(backoff)
                 else:
                     raise RuntimeError(f"沙箱服务不可用: {e}")
 
@@ -377,38 +431,32 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
     # ============== 内部方法 - 异步版本 ==============
 
     async def _post_async(self, endpoint: str, data: dict, timeout: int = None) -> dict:
-        """异步 POST 请求（每次创建独立 session，避免跨 Task 共享导致超时上下文错误）"""
+        """异步 POST 请求（使用共享连接池）"""
         actual_timeout = timeout if timeout is not None else self._timeout
         if "/execute" in endpoint:
             http_timeout = actual_timeout + 60
         else:
             http_timeout = actual_timeout + 30
 
-        trace_id = SYLogger.get_trace_id()
-        headers = {"Content-Type": "application/json"}
-        if trace_id:
-            headers["x-traceid-header"] = str(trace_id)
-        if self._token:
-            headers["X-Sandbox-Token"] = self._token
+        headers = self._build_headers()
 
         url = f"{self._base_url}{endpoint}"
         SYLogger.info(f"[Sandbox] Async POST 请求开始: {url}, timeout={http_timeout}s")
 
         timeout_obj = aiohttp.ClientTimeout(total=http_timeout)
-        connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
-        async with aiohttp.ClientSession(connector=connector) as session:
-            async with session.post(url, json=data, headers=headers, timeout=timeout_obj) as resp:
-                SYLogger.info(f"[Sandbox] Async POST 响应状态码: {resp.status}")
-                if resp.status >= 400:
-                    text = await resp.text()
-                    SYLogger.error(f"[Sandbox] HTTP 错误 {resp.status}: {text}")
-                    resp.raise_for_status()
-                result = await resp.json()
-                SYLogger.info(f"[Sandbox] Async POST 成功: {url}")
-                return result
+        session = await self._get_async_session()
+        async with session.post(url, json=data, headers=headers, timeout=timeout_obj) as resp:
+            SYLogger.info(f"[Sandbox] Async POST 响应状态码: {resp.status}")
+            if resp.status >= 400:
+                text = await resp.text()
+                SYLogger.error(f"[Sandbox] HTTP 错误 {resp.status}: {text}")
+                resp.raise_for_status()
+            result = await resp.json()
+            SYLogger.info(f"[Sandbox] Async POST 成功: {url}")
+            return result
 
     async def _post_async_with_failover(self, endpoint: str, data: dict, timeout: int = None) -> dict:
-        """带故障转移的异步 POST 请求"""
+        """带故障转移和指数退避的异步 POST 请求"""
         max_retries = 3
 
         for attempt in range(max_retries):
@@ -418,10 +466,12 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                 SYLogger.warning(f"[Sandbox] Async 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
 
                 if attempt < max_retries - 1:
+                    # 指数退避: 1s, 2s
+                    backoff = 2 ** attempt
                     # 尝试故障转移
                     switched = await asyncio.to_thread(self._refresh_from_nacos_and_switch_sync)
                     if not switched:
-                        await asyncio.sleep(1)
+                        await asyncio.sleep(backoff)
                 else:
                     raise RuntimeError(f"沙箱服务不可用: {e}")
 
@@ -490,20 +540,19 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             SYLogger.info(f"[Sandbox] 使用环境变量 SANDBOX_WORKSPACE={env_workspace}")
             return self._workspace_root
 
-        # 从沙箱服务端 health 接口获取（aiohttp 异步）
+        # 从沙箱服务端 health 接口获取（使用共享连接池）
         try:
             url = f"{self._base_url}{SANDBOX_API_PREFIX}/health"
-            connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
             timeout_obj = aiohttp.ClientTimeout(total=10)
-            async with aiohttp.ClientSession(connector=connector) as session:
-                async with session.get(url, timeout=timeout_obj) as resp:
-                    if resp.status == 200:
-                        data = await resp.json()
-                        workspace = data.get("workspace", "")
-                        if workspace:
-                            self._workspace_root = workspace
-                            SYLogger.info(f"[Sandbox] 从沙箱服务端获取 WORKSPACE_ROOT={workspace}")
-                            return self._workspace_root
+            session = await self._get_async_session()
+            async with session.get(url, timeout=timeout_obj) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    workspace = data.get("workspace", "")
+                    if workspace:
+                        self._workspace_root = workspace
+                        SYLogger.info(f"[Sandbox] 从沙箱服务端获取 WORKSPACE_ROOT={workspace}")
+                        return self._workspace_root
         except Exception as e:
             SYLogger.warning(f"[Sandbox] 异步获取沙箱 workspace 失败: {e}")
 
@@ -1071,7 +1120,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                     failed_count += 1
                     errors.append({"path": sandbox_path, "error": str(e)})
 
-        max_workers = min(8, len(files_to_upload)) if files_to_upload else 1
+        max_workers = min(4, len(files_to_upload)) if files_to_upload else 1
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
             futures = [
                 executor.submit(_upload_one, idx, sandbox_path, local_file)
@@ -1185,18 +1234,17 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             raise
 
     async def ahealth_check(self, timeout: int = 10) -> dict:
-        """异步健康检查"""
+        """异步健康检查（使用共享连接池）"""
         try:
             headers = self._build_headers()
             url = f"{self._base_url}{SANDBOX_API_PREFIX}/health"
             timeout_obj = aiohttp.ClientTimeout(total=timeout)
-            connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
-            async with aiohttp.ClientSession(connector=connector) as session:
-                async with session.get(url, headers=headers, timeout=timeout_obj) as resp:
-                    resp.raise_for_status()
-                    result = await resp.json()
-                    SYLogger.info(f"[Sandbox] 异步健康检查成功: {result}")
-                    return result
+            session = await self._get_async_session()
+            async with session.get(url, headers=headers, timeout=timeout_obj) as resp:
+                resp.raise_for_status()
+                result = await resp.json()
+                SYLogger.info(f"[Sandbox] 异步健康检查成功: {result}")
+                return result
         except Exception as e:
             SYLogger.error(f"[Sandbox] 异步健康检查失败: {e}")
             raise

{sycommon_python_lib-0.2.5a13 → sycommon_python_lib-0.2.5a14}/src/sycommon/middleware/sandbox.py

@@ -67,7 +67,8 @@ from sycommon.models.sandbox import (
 _WORKER_ID = f"{os.getpid()}-{uuid.uuid4().hex[:8]}"
 
 # 进程存储: process_id -> {process: Popen, command: str, user_id: str, started_at: datetime, workspace: str}
-
+_background_processes: Dict = {}
+_process_lock = None
 
 
 def _get_process_lock() -> asyncio.Lock:
@@ -403,7 +404,13 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
     @sandbox_router.get("/health", response_model=HealthResponse)
     async def health():
         """健康检查，返回 worker_id 用于多 worker 部署下的路由定位"""
-        return HealthResponse(status="ok", workspace=WORKSPACE_BASE)
+        return HealthResponse(
+            status="ok",
+            workspace=WORKSPACE_BASE,
+            name=os.environ.get("SANDBOX_NAME", "远程沙箱"),
+            description=os.environ.get("SANDBOX_DESCRIPTION", ""),
+            type="remote",
+        )
 
     @sandbox_router.post("/execute", response_model=ExecuteResponse)
     async def execute(req: ExecuteRequest):

{sycommon_python_lib-0.2.5a13 → sycommon_python_lib-0.2.5a14}/src/sycommon/models/sandbox.py

@@ -182,6 +182,9 @@ class HealthResponse(BaseModel):
     """健康检查响应"""
     status: str
     workspace: str
+    name: str = ""
+    description: str = ""
+    type: str = "remote"
 
 
 class ResetRequest(BaseModel):

{sycommon_python_lib-0.2.5a13 → sycommon_python_lib-0.2.5a14}/src/sycommon/tools/snowflake.py

@@ -4,44 +4,37 @@ import socket
 import hashlib
 import random
 import os
-from typing import Optional, Type, Any
-from os import environ
 import psutil
+from typing import Optional, Any
 
 
 class ClassProperty:
-    """支持通过 类.属性 的方式访问，无需实例化"""
-
     def __init__(self, func):
         self.func = func
 
-    def __get__(self, instance: Any, cls: Type) -> str:
+    def __get__(self, instance: Any, cls: type) -> str:
         return self.func(cls)
 
 
 class Snowflake:
     """
-    雪花算法生成器（高并发终极优化版 - 修复语法错误）
+    雪花算法生成器
 
-    终极优化点：
-    1. 解决溢出死锁：当序列号溢出时，释放锁自旋等待，避免阻塞其他线程。
-    2. 锁内原子更新：确保时钟回拨判断与状态更新的原子性。
-    3. 移除 sleep：全流程无休眠，纯自旋保证极致吞吐。
-    4. 机器ID分段：Python服务使用0-511，避免与Java服务(512-1023)冲突
+    - 序列号溢出时释放锁自旋等待，避免阻塞其他线程
+    - 机器ID分段：Python服务使用4096~5119，避免与Java服务(0~4095)冲突
     """
+
     START_TIMESTAMP = 1388534400000  # 2014-01-01 00:00:00
-    SEQUENCE_BITS = 12
-    MACHINE_ID_BITS = 10
-    MAX_MACHINE_ID = (1 << MACHINE_ID_BITS) - 1  # 0~1023
-    MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1     # 4095
+    SEQUENCE_BITS = 9
+    MACHINE_ID_BITS = 13
+    MAX_MACHINE_ID = (1 << MACHINE_ID_BITS) - 1  # 0~8191
+    MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1     # 511
     MACHINE_ID_SHIFT = SEQUENCE_BITS
     TIMESTAMP_SHIFT = SEQUENCE_BITS + MACHINE_ID_BITS
     CLOCK_BACKWARD_THRESHOLD = 5
     _MAX_JAVA_LONG = 9223372036854775807
 
-    # 机器ID分段配置（避免不同语言服务ID冲突）
-    # Python服务: 512-1023, Java服务: 0-511
-    PYTHON_MACHINE_ID_MIN = 512
+    PYTHON_MACHINE_ID_MIN = 4096
 
     _instance = None
     _instance_lock = threading.Lock()
@@ -51,12 +44,9 @@ class Snowflake:
         if machine_id is None:
             machine_id = self._get_k8s_machine_id()
 
-        # Python服务机器ID限制在512-1023范围，避免与Java服务(0-511)冲突
+        # Python服务机器ID限制在4096~5119范围，避免与Java服务(0~4095)冲突
         machine_id = self.PYTHON_MACHINE_ID_MIN + \
-            (machine_id % (self.MAX_MACHINE_ID - self.PYTHON_MACHINE_ID_MIN + 1))
-
-        if not (0 <= machine_id <= self.MAX_MACHINE_ID):
-            raise ValueError(f"机器ID必须在0~{self.MAX_MACHINE_ID}之间")
+            (machine_id % (5120 - self.PYTHON_MACHINE_ID_MIN))
 
         self.machine_id = machine_id
         self.last_timestamp = -1
@@ -66,15 +56,14 @@ class Snowflake:
     def _validate_timestamp_range(self):
         max_support_timestamp = self.START_TIMESTAMP + \
             (1 << (64 - self.TIMESTAMP_SHIFT)) - 1
-        current_timestamp = self._get_current_timestamp()
-        if current_timestamp > max_support_timestamp:
-            raise RuntimeError(f"当前时间戳({current_timestamp})超过支持范围")
+        if self._get_current_timestamp() > max_support_timestamp:
+            raise RuntimeError("当前时间戳超过支持范围")
 
     def _get_k8s_machine_id(self) -> int:
-        pod_name = environ.get("POD_NAME")
+        pod_name = os.environ.get("POD_NAME")
         if pod_name:
             return self._hash_to_machine_id(pod_name)
-        pod_ip = environ.get("POD_IP")
+        pod_ip = os.environ.get("POD_IP")
         if pod_ip:
             return self._hash_to_machine_id(pod_ip)
         try:
@@ -117,8 +106,7 @@ class Snowflake:
             pass
         try:
             hostname = socket.gethostname()
-            ip_list = socket.gethostbyname_ex(hostname)[2]
-            for ip in ip_list:
+            for ip in socket.gethostbyname_ex(hostname)[2]:
                 if not ip.startswith('127.') and not ip.startswith('0.'):
                     return ip
         except Exception:
@@ -133,69 +121,39 @@ class Snowflake:
         return int(time.time() * 1000)
 
     def generate_id(self) -> int:
-        """
-        生成雪花ID（高并发优化版）
-        使用 while True 循环来处理序列号溢出时的重试逻辑
-        """
         while True:
-            # 1. 快速获取当前时间
             current_timestamp = self._get_current_timestamp()
 
-            # 2. 加锁，保证状态更新的原子性
             with self.lock:
-                # 读取当前状态（快照）
                 last_timestamp = self.last_timestamp
-                sequence = self.sequence
 
-                # 2.1 处理时钟回拨
+                # 时钟回拨处理
                 time_diff = last_timestamp - current_timestamp
                 if time_diff > 0:
                     if time_diff > self.CLOCK_BACKWARD_THRESHOLD:
-                        # 大幅回拨：直接“借用”未来1ms
                         current_timestamp = last_timestamp + 1
                     else:
-                        # 微小回拨：锁内自旋等待追上（通常很快）
                         while current_timestamp <= last_timestamp:
                             current_timestamp = self._get_current_timestamp()
 
-                # 2.2 计算序列号
                 if current_timestamp == last_timestamp:
-                    # 同一毫秒内
-                    sequence = (sequence + 1) & self.MAX_SEQUENCE
-                    if sequence == 0:
-                        self.lock.release()  # 手动释放锁
-
-                        # 锁外自旋等待下一毫秒
+                    self.sequence = (self.sequence + 1) & self.MAX_SEQUENCE
+                    if self.sequence == 0:
+                        # 序列号溢出：自旋等待下一毫秒（锁内等待，保证状态一致）
                         while current_timestamp <= last_timestamp:
                             current_timestamp = self._get_current_timestamp()
+                    # else: sequence 正常递增，继续往下生成
+                elif current_timestamp > last_timestamp:
+                    self.sequence = 0
 
-                        # 等待到了新毫秒，进入下一轮循环（continue 默认行为），重新抢锁竞争
-                        continue
+                self.last_timestamp = current_timestamp
 
-                elif current_timestamp > last_timestamp:
-                    # 时间推进，重置序列号
-                    sequence = 0
-                    self.last_timestamp = current_timestamp
-                    self.sequence = sequence
-                else:
-                    # current < last 的情况通常已被回拨逻辑处理
-                    pass
-
-                # 2.4 生成 ID
-                snowflake_id = (
-                    ((current_timestamp - self.START_TIMESTAMP)
-                     << self.TIMESTAMP_SHIFT)
+                return (
+                    ((current_timestamp - self.START_TIMESTAMP) << self.TIMESTAMP_SHIFT)
                     | (self.machine_id << self.MACHINE_ID_SHIFT)
-                    | sequence
+                    | self.sequence
                 )
 
-                # 更新全局状态（如果是同一毫秒）
-                if current_timestamp == self.last_timestamp:
-                    self.sequence = sequence
-
-            # 成功生成 ID，退出循环
-            return snowflake_id
-
     @staticmethod
     def parse_id(snowflake_id: int) -> dict:
         from datetime import datetime
@@ -206,8 +164,6 @@ class Snowflake:
             Snowflake.START_TIMESTAMP
         generate_time = datetime.fromtimestamp(
             timestamp / 1000).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
-
-        # 判断服务来源（Python: 512-1023, Java: 0-511）
         service_type = "python" if machine_id >= Snowflake.PYTHON_MACHINE_ID_MIN else "java"
 
         return {
@@ -235,7 +191,7 @@ class Snowflake:
 if __name__ == "__main__":
     import concurrent.futures
 
-    print("=== 高并发终极版 Snowflake 性能测试 ===")
+    print("=== Snowflake 性能测试 ===")
     count = 100000
     workers = 100
 
@@ -245,7 +201,7 @@ if __name__ == "__main__":
     def task():
         return Snowflake.id
 
-    with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
+    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
         futures = [executor.submit(task) for _ in range(count)]
         for future in concurrent.futures.as_completed(futures):
             ids.append(future.result())
@@ -256,7 +212,7 @@ if __name__ == "__main__":
     unique_count = len(set(ids))
     print(f"生成数量: {len(ids)}")
     print(f"唯一ID数量: {unique_count}")
-    print(f"是否有重复: {'是 ❌' if unique_count != len(ids) else '否 ✅'}")
+    print(f"是否有重复: {'是' if unique_count != len(ids) else '否'}")
     print(f"总耗时: {duration:.4f} 秒")
     print(f"吞吐量 (QPS): {len(ids) / duration:,.2f}")
     print("\n最后一个ID解析:")

{sycommon_python_lib-0.2.5a13 → sycommon_python_lib-0.2.5a14}/src/sycommon_python_lib.egg-info/PKG-INFO

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