pixelarraythirdparty 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

pixelarraythirdparty/__init__.py

@@ -8,9 +8,10 @@ PixelArray 第三方微服务客户端
 - product: 产品管理模块
 - cron: 定时任务管理模块
 - user: 用户管理模块
+- unified_login: 统一登录模块
 """
 
-__version__ = "1.0.8"
+__version__ = "1.0.9"
 __author__ = "Lu qi"
 __email__ = "qi.lu@pixelarrayai.com"
 
@@ -21,4 +22,5 @@ __all__ = [
     "user",
     "order",
     "filestorage",
+    "unified_login",
 ]

pixelarraythirdparty/filestorage/filestorage.py

@@ -1,15 +1,16 @@
 from pixelarraythirdparty.client import AsyncClient
-from typing import Dict, Any, Optional, List, Tuple, Callable, Union
+from typing import Dict, Any, Optional, List, Tuple, AsyncGenerator
 import os
-import asyncio
 import aiohttp
 import mimetypes
+import math
+import time
 
 
 class FileStorageManagerAsync(AsyncClient):
     async def upload(
         self, file_path: str, parent_id: Optional[int] = None
-    ) -> Tuple[bool, Dict[str, Any]]:
+    ) -> Tuple[Dict[str, Any], bool]:
         """
         description:
             上传文件（合并了初始化、分片上传、完成上传三个步骤）
@@ -20,14 +21,30 @@ class FileStorageManagerAsync(AsyncClient):
             - data: 结果数据
             - success: 是否成功
         """
-        # 读取文件数据
+        final_result: Dict[str, Any] = {}
+        final_success = False
+        async for progress in self.upload_stream(file_path, parent_id):
+            event = progress.get("event")
+            if event == "error":
+                return {}, False
+            if event == "complete" and progress.get("success"):
+                final_result = progress.get("result", {})
+                final_success = True
+        return final_result, final_success
+
+    async def upload_stream(
+        self, file_path: str, parent_id: Optional[int] = None
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        description:
+            上传文件（流式，返回生成器，包含进度信息）
+        """
+        chunk_size = 2 * 1024 * 1024  # 2MB
+        upload_start = time.perf_counter()
         with open(file_path, "rb") as f:
             file_bytes = f.read()
 
         total_size = len(file_bytes)
-        chunk_size = 2 * 1024 * 1024  # 2MB
-
-        # 1. 初始化上传
         file_name = os.path.basename(file_path)
         mime_type = mimetypes.guess_type(file_path)[0]
         init_data = {
@@ -42,63 +59,135 @@ class FileStorageManagerAsync(AsyncClient):
             "POST", "/api/file_storage/upload/init", json=init_data
         )
         if not success:
-            return {}, False
+            yield {
+                "event": "error",
+                "percentage": 0,
+                "total_chunks": 0,
+                "remaining_chunks": 0,
+                "total_bytes": total_size,
+                "processed_bytes": 0,
+                "speed": 0,
+                "message": "初始化上传失败",
+                "success": False,
+            }
+            return
 
         upload_id = init_result.get("upload_id")
         chunk_urls = init_result.get("chunk_urls", [])
         total_chunks = len(chunk_urls)
 
         if not upload_id or not chunk_urls:
-            return {}, False
-
-        # 2. 上传所有分片
-        parts = []
-
-        async def upload_single_chunk(chunk_index: int, chunk_data: bytes):
-            """上传单个分片"""
-            chunk_info = chunk_urls[chunk_index]
-            part_number = chunk_info.get("part_number")
-            url = chunk_info.get("url")
+            yield {
+                "event": "error",
+                "percentage": 0,
+                "total_chunks": 0,
+                "remaining_chunks": 0,
+                "total_bytes": total_size,
+                "processed_bytes": 0,
+                "speed": 0,
+                "message": "缺少上传ID或分片信息",
+                "success": False,
+            }
+            return
+
+        yield {
+            "event": "init",
+            "percentage": 0,
+            "total_chunks": total_chunks,
+            "remaining_chunks": total_chunks,
+            "total_bytes": total_size,
+            "processed_bytes": 0,
+            "speed": 0,
+            "message": "初始化完成，开始上传分片",
+            "success": True,
+        }
 
-            if not url or not part_number:
-                return None
+        parts: List[Dict[str, Any]] = []
+        uploaded_bytes = 0
 
-            # 使用预签名URL直接上传到OSS（PUT请求）
-            async with aiohttp.ClientSession() as session:
-                async with session.put(url, data=chunk_data) as resp:
-                    if resp.status == 200:
+        async with aiohttp.ClientSession() as session:
+            for idx, chunk_info in enumerate(chunk_urls):
+                part_number = chunk_info.get("part_number")
+                url = chunk_info.get("url")
+                start = idx * chunk_size
+                end = min(start + chunk_size, total_size)
+                chunk_data = file_bytes[start:end]
+
+                if not url or not part_number:
+                    percentage = (
+                        0
+                        if total_size == 0
+                        else min((uploaded_bytes / total_size) * 100, 100)
+                    )
+                    yield {
+                        "event": "error",
+                        "percentage": percentage,
+                        "total_chunks": total_chunks,
+                        "remaining_chunks": total_chunks - idx,
+                        "total_bytes": total_size,
+                        "processed_bytes": uploaded_bytes,
+                        "speed": 0,
+                        "message": "分片信息缺失",
+                        "success": False,
+                    }
+                    return
+
+                chunk_start = time.perf_counter()
+                try:
+                    async with session.put(url, data=chunk_data) as resp:
+                        if resp.status != 200:
+                            raise RuntimeError(
+                                f"分片上传失败，状态码：{resp.status}"
+                            )
                         etag = resp.headers.get("ETag", "").strip('"')
-                        return {
-                            "part_number": part_number,
-                            "etag": etag,
-                            "chunk_index": chunk_index,
-                        }
-            return None
-
-        # 并发上传所有分片
-        tasks = []
-        for i in range(total_chunks):
-            start = i * chunk_size
-            end = min(start + chunk_size, total_size)
-            chunk_data = file_bytes[start:end]
-            tasks.append(upload_single_chunk(i, chunk_data))
-
-        # 等待所有分片上传完成，并收集结果
-        results = await asyncio.gather(*tasks)
-
-        # 检查上传结果并更新进度
-        # 按chunk_index排序，确保parts顺序正确
-        sorted_results = sorted(
-            [r for r in results if r is not None], key=lambda x: x.get("chunk_index", 0)
-        )
+                        parts.append(
+                            {
+                                "part_number": part_number,
+                                "etag": etag,
+                            }
+                        )
+                except Exception as exc:
+                    percentage = (
+                        0
+                        if total_size == 0
+                        else min((uploaded_bytes / total_size) * 100, 100)
+                    )
+                    yield {
+                        "event": "error",
+                        "percentage": percentage,
+                        "total_chunks": total_chunks,
+                        "remaining_chunks": max(total_chunks - idx, 0),
+                        "total_bytes": total_size,
+                        "processed_bytes": uploaded_bytes,
+                        "speed": 0,
+                        "message": f"分片上传异常：{exc}",
+                        "success": False,
+                    }
+                    return
+
+                uploaded_bytes += len(chunk_data)
+                duration = max(time.perf_counter() - chunk_start, 1e-6)
+                speed = len(chunk_data) / duration
+                percentage = (
+                    100
+                    if total_size == 0
+                    else min((uploaded_bytes / total_size) * 100, 100)
+                )
+
+                yield {
+                    "event": "chunk",
+                    "percentage": percentage,
+                    "total_chunks": total_chunks,
+                    "remaining_chunks": max(total_chunks - (idx + 1), 0),
+                    "total_bytes": total_size,
+                    "processed_bytes": uploaded_bytes,
+                    "chunk_index": idx,
+                    "chunk_size": len(chunk_data),
+                    "speed": speed,
+                    "message": f"分片{idx + 1}/{total_chunks}上传完成",
+                    "success": True,
+                }
 
-        if len(sorted_results) != total_chunks:
-            return {}, False
-
-        for i, result in enumerate(sorted_results):
-            parts.append({"part_number": result["part_number"], "etag": result["etag"]})
-
-        # 3. 完成上传
         complete_data = {
             "upload_id": upload_id,
             "parts": parts,
@@ -107,9 +196,32 @@ class FileStorageManagerAsync(AsyncClient):
             "POST", "/api/file_storage/upload/complete", json=complete_data
         )
         if not success:
-            return {}, False
-
-        return complete_result, True
+            yield {
+                "event": "error",
+                "percentage": 100,
+                "total_chunks": total_chunks,
+                "remaining_chunks": 0,
+                "total_bytes": total_size,
+                "processed_bytes": total_size,
+                "speed": 0,
+                "message": "完成上传失败",
+                "success": False,
+            }
+            return
+
+        total_duration = max(time.perf_counter() - upload_start, 1e-6)
+        yield {
+            "event": "complete",
+            "percentage": 100,
+            "total_chunks": total_chunks,
+            "remaining_chunks": 0,
+            "total_bytes": total_size,
+            "processed_bytes": total_size,
+            "speed": total_size / total_duration if total_duration else 0,
+            "message": "上传完成",
+            "success": True,
+            "result": complete_result,
+        }
 
     async def list_files(
         self,
@@ -255,32 +367,164 @@ class FileStorageManagerAsync(AsyncClient):
             - data: 下载结果数据
             - success: 是否成功
         """
-        # 1. 生成签名URL
+        final_result: Dict[str, Any] = {}
+        final_success = False
+        async for progress in self.download_stream(record_id, save_path):
+            event = progress.get("event")
+            if event == "error":
+                return {}, False
+            if event == "complete" and progress.get("success"):
+                final_result = progress.get("result", {})
+                final_success = True
+        return final_result, final_success
+
+    async def download_stream(
+        self,
+        record_id: int,
+        save_path: str,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        description:
+            下载文件（流式，返回生成器）
+        """
+        chunk_size = 2 * 1024 * 1024
         signed_url_data, success = await self.generate_signed_url(record_id)
         if not success:
-            return {}, False
+            yield {
+                "event": "error",
+                "percentage": 0,
+                "total_chunks": 0,
+                "remaining_chunks": 0,
+                "total_bytes": 0,
+                "processed_bytes": 0,
+                "speed": 0,
+                "message": "生成签名URL失败",
+                "success": False,
+            }
+            return
 
         signed_url = signed_url_data.get("signed_url")
-        file_record = signed_url_data.get("file_record", {})
-        total_size = file_record.get("file_size", 0)
+        file_record = signed_url_data.get("file_record", {}) or {}
+        total_size = file_record.get("file_size", 0) or 0
 
         if not signed_url:
-            return {}, False
-
-        # 2. 下载文件
-        async with aiohttp.ClientSession() as session:
-            async with session.get(signed_url) as resp:
-                if resp.status != 200:
-                    return {}, False
-
-                file_data = b""
-                downloaded = 0
+            yield {
+                "event": "error",
+                "percentage": 0,
+                "total_chunks": 0,
+                "remaining_chunks": 0,
+                "total_bytes": total_size,
+                "processed_bytes": 0,
+                "speed": 0,
+                "message": "签名URL为空",
+                "success": False,
+            }
+            return
+
+        total_chunks = math.ceil(total_size / chunk_size) if total_size else 0
+
+        yield {
+            "event": "init",
+            "percentage": 0,
+            "total_chunks": total_chunks,
+            "remaining_chunks": total_chunks,
+            "total_bytes": total_size,
+            "processed_bytes": 0,
+            "speed": 0,
+            "message": "开始下载文件",
+            "success": True,
+        }
 
-                async for chunk in resp.content.iter_chunked(8192):  # 8KB chunks
-                    file_data += chunk
-                    downloaded += len(chunk)
+        os.makedirs(os.path.dirname(save_path) or ".", exist_ok=True)
 
-                with open(save_path, "wb") as f:
-                    f.write(file_data)
+        downloaded_bytes = 0
+        chunk_index = 0
+        download_start = time.perf_counter()
 
-                return {"total_size": total_size, "success": True}, True
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.get(signed_url) as resp:
+                    if resp.status != 200:
+                        raise RuntimeError(f"文件下载失败，状态码：{resp.status}")
+
+                    header_size = resp.headers.get("Content-Length")
+                    if total_size == 0 and header_size:
+                        try:
+                            total_size = int(header_size)
+                            total_chunks = (
+                                math.ceil(total_size / chunk_size)
+                                if total_size
+                                else 0
+                            )
+                        except ValueError:
+                            total_size = 0
+
+                    with open(save_path, "wb") as f:
+                        async for chunk in resp.content.iter_chunked(chunk_size):
+                            chunk_start = time.perf_counter()
+                            chunk_index += 1
+                            downloaded_bytes += len(chunk)
+                            f.write(chunk)
+
+                            chunk_duration = max(
+                                time.perf_counter() - chunk_start, 1e-6
+                            )
+                            instant_speed = len(chunk) / chunk_duration
+                            percentage = (
+                                0
+                                if total_size == 0
+                                else min(
+                                    (downloaded_bytes / total_size) * 100, 100
+                                )
+                            )
+                            remaining = (
+                                max(total_chunks - chunk_index, 0)
+                                if total_chunks
+                                else 0
+                            )
+
+                            yield {
+                                "event": "chunk",
+                                "percentage": percentage,
+                                "total_chunks": total_chunks,
+                                "remaining_chunks": remaining,
+                                "total_bytes": total_size,
+                                "processed_bytes": downloaded_bytes,
+                                "chunk_index": chunk_index - 1,
+                                "chunk_size": len(chunk),
+                                "speed": instant_speed,
+                                "message": f"分片{chunk_index}/{total_chunks or '?'}下载完成",
+                                "success": True,
+                            }
+            except Exception as exc:
+                yield {
+                    "event": "error",
+                    "percentage": 0,
+                    "total_chunks": total_chunks,
+                    "remaining_chunks": total_chunks,
+                    "total_bytes": total_size,
+                    "processed_bytes": downloaded_bytes,
+                    "speed": 0,
+                    "message": f"下载过程中发生错误：{exc}",
+                    "success": False,
+                }
+                return
+
+        total_duration = max(time.perf_counter() - download_start, 1e-6)
+        result = {
+            "total_size": total_size,
+            "success": True,
+        }
+        yield {
+            "event": "complete",
+            "percentage": 100,
+            "total_chunks": total_chunks,
+            "remaining_chunks": 0,
+            "total_bytes": total_size,
+            "processed_bytes": total_size if total_size else downloaded_bytes,
+            "speed": (total_size or downloaded_bytes)
+            / max(total_duration, 1e-6),
+            "message": "下载完成",
+            "success": True,
+            "result": result,
+        }

pixelarraythirdparty/unified_login/__init__.py

@@ -0,0 +1,16 @@
+from .unified_login import (
+    ThirdPartyAuthUrlRequest,
+    ThirdPartyAuthUrlResponse,
+    ThirdPartyLoginRequest,
+    ThirdPartyLoginResponse,
+    UnifiedLoginClientAsync,
+)
+
+__all__ = [
+    "ThirdPartyAuthUrlRequest",
+    "ThirdPartyAuthUrlResponse",
+    "ThirdPartyLoginRequest",
+    "ThirdPartyLoginResponse",
+    "UnifiedLoginClientAsync",
+]
+

pixelarraythirdparty/unified_login/unified_login.py

@@ -0,0 +1,18 @@
+from client.pypi.pixelarraythirdparty.client import AsyncClient
+
+
+class GoogleLogin(AsyncClient):
+    async def _get_auth_url(self):
+        pass
+        
+    async def _get_code_from_redirect_uri(self, redirect_uri: str):
+        pass
+
+    async def _get_user_info(self, token: str) -> dict:
+        pass
+
+    async def login(self) -> dict:
+        pass
+
+    async def logout(self) -> dict:
+        pass

{pixelarraythirdparty-1.0.8.dist-info → pixelarraythirdparty-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixelarraythirdparty
-Version: 1.0.8
+Version: 1.0.9
 Summary: PixelArray 第三方微服务客户端
 Author-email: Lu qi <qi.lu@pixelarrayai.com>
 License-Expression: MIT

{pixelarraythirdparty-1.0.8.dist-info → pixelarraythirdparty-1.0.9.dist-info}/RECORD

@@ -1,17 +1,19 @@
-pixelarraythirdparty/__init__.py,sha256=IaxhSmTdxqDsLwS2tQ9Bg6vqPG1ZSAO_OHTj14jcTbY,473
+pixelarraythirdparty/__init__.py,sha256=4Ow9-OH9uZppYgQhTOYXcxQoApTGNf6b2vdv-wgGcEs,530
 pixelarraythirdparty/client.py,sha256=hYLLzW8uhw6Qe0rLN1j0qx1HOUMSiclrr6nHjmzJwUw,1305
 pixelarraythirdparty/cron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixelarraythirdparty/cron/cron.py,sha256=2g2Js23X5fINmyq41H3wosDuCbUbHjKqFpBK9EqSEeY,5661
 pixelarraythirdparty/filestorage/__init__.py,sha256=R4aObBoUs9EuLxNxtcFrouHFoitWdf5MOtXv3A60smk,130
-pixelarraythirdparty/filestorage/filestorage.py,sha256=p2unkhtjxMdt_MLN6f10WFNMA9CJtEahZe7PpXySAmU,8893
+pixelarraythirdparty/filestorage/filestorage.py,sha256=MGsGeU57DdK1KW7RPTaIJe2RXxqtXd5wKAanJO9PCj8,18583
 pixelarraythirdparty/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixelarraythirdparty/order/order.py,sha256=EamnHxiZqXxDVctb44T6fwWtJhTgLpzgGArxQRSvR14,14178
 pixelarraythirdparty/product/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixelarraythirdparty/product/product.py,sha256=a6BFUnq0D-s8fVlWV3RKyCsBNE_5sqgwq5W5GmmRNto,10521
+pixelarraythirdparty/unified_login/__init__.py,sha256=JRIBS9vwCXAJWzxTusb2Pt2f5m3u0braB9YeLYJpkEE,351
+pixelarraythirdparty/unified_login/unified_login.py,sha256=OngSCSYL738JJaX9RaxaEq2ilGSkcc7gtbwXxq-0HV4,405
 pixelarraythirdparty/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixelarraythirdparty/user/user.py,sha256=1Dna4-St7AnDZRbjVuOuI84ho5wcnL7Hr3sq8oXo3bo,8383
-pixelarraythirdparty-1.0.8.dist-info/licenses/LICENSE,sha256=O-g1dUr0U50rSIvmWE9toiVkSgFpVt72_MHITbWvAqA,1067
-pixelarraythirdparty-1.0.8.dist-info/METADATA,sha256=y_iQZnBl2dUb0MO4ZKpMc2l9q5oPcKvZz4PPNJElRlg,993
-pixelarraythirdparty-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pixelarraythirdparty-1.0.8.dist-info/top_level.txt,sha256=dzG2Ut8j7noUqj_0ZQjcIDAeHYCh_9WtlxjAxtoyufo,21
-pixelarraythirdparty-1.0.8.dist-info/RECORD,,
+pixelarraythirdparty-1.0.9.dist-info/licenses/LICENSE,sha256=O-g1dUr0U50rSIvmWE9toiVkSgFpVt72_MHITbWvAqA,1067
+pixelarraythirdparty-1.0.9.dist-info/METADATA,sha256=Qk-0DzGTjnXsTe7dFOlS0S0_Ia-XRX5RbMC9ILAA4Mk,993
+pixelarraythirdparty-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pixelarraythirdparty-1.0.9.dist-info/top_level.txt,sha256=dzG2Ut8j7noUqj_0ZQjcIDAeHYCh_9WtlxjAxtoyufo,21
+pixelarraythirdparty-1.0.9.dist-info/RECORD,,