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

pixelarraythirdparty/__init__.py

@@ -10,7 +10,7 @@ PixelArray 第三方微服务客户端
 - user: 用户管理模块
 """
 
-__version__ = "1.0.7"
+__version__ = "1.0.8"
 __author__ = "Lu qi"
 __email__ = "qi.lu@pixelarrayai.com"
 
@@ -20,4 +20,5 @@ __all__ = [
     "cron",
     "user",
     "order",
+    "filestorage",
 ]

pixelarraythirdparty/client.py

@@ -1,28 +1,5 @@
-import requests
 import aiohttp
-from typing import Dict, Any, Optional, Tuple
-import asyncio
-
-
-class Client:
-    """基础认证类，提供公共的 API key 认证和请求方法"""
-
-    def __init__(self, api_key: str):
-        self.base_url = "https://thirdparty.pixelarrayai.com"
-        self.api_key = api_key
-        self.headers = {
-            "Content-Type": "application/json",
-            "X-API-Key": self.api_key,
-        }
-
-    def _request(self, method: str, url: str, **kwargs) -> Tuple[Dict[str, Any], bool]:
-        """统一的请求方法"""
-        resp = requests.request(
-            method, f"{self.base_url}{url}", headers=self.headers, **kwargs
-        )
-        if resp.status_code == 200 and resp.json().get("success") is True:
-            return resp.json().get("data", {}), True
-        return {}, False
+from typing import Dict, Any, Tuple
 
 
 class AsyncClient:
@@ -34,14 +11,26 @@ class AsyncClient:
             "X-API-Key": self.api_key,
         }
 
-    async def _request(self, method: str, url: str, **kwargs) -> Tuple[Dict[str, Any], bool]:
+    async def _request(
+        self, method: str, url: str, **kwargs
+    ) -> Tuple[Dict[str, Any], bool]:
+        # 如果kwargs中有headers，则合并headers
+        headers = self.headers.copy()
+        if "headers" in kwargs:
+            headers.update(kwargs["headers"])
+            kwargs = {k: v for k, v in kwargs.items() if k != "headers"}
+
         async with aiohttp.ClientSession() as session:
             req_method = getattr(session, method.lower())
             async with req_method(
-                f"{self.base_url}{url}", headers=self.headers, **kwargs
+                f"{self.base_url}{url}", headers=headers, **kwargs
             ) as resp:
                 if resp.status == 200:
-                    result = await resp.json()
-                    if result.get("success") is True:
-                        return result.get("data", {}), True
+                    try:
+                        result = await resp.json()
+                        if result.get("success") is True:
+                            return result.get("data", {}), True
+                    except:
+                        # 如果不是JSON响应，返回空
+                        pass
                 return {}, False

pixelarraythirdparty/cron/cron.py

@@ -1,17 +1,17 @@
-from pixelarraythirdparty.client import Client
+from pixelarraythirdparty.client import AsyncClient
 
 
-class CronManager(Client):
-    def get_cron_status(self):
+class CronManagerAsync(AsyncClient):
+    async def get_cron_status(self):
         """
-        获取Cron服务状态
-        
+        获取Cron服务状态（异步版本）
+
         功能说明：
             获取Cron服务的运行状态，包括已注册的任务、工作节点状态等。
-        
+
         输入参数：
             无
-        
+
         返回字段：
             data (dict): Cron服务状态信息
                 - registered_tasks (dict): 已注册的任务列表，按工作节点分组
@@ -19,50 +19,50 @@ class CronManager(Client):
                 - scheduled_task_count (int): 定时任务数量
                 - timestamp (str): 状态获取时间
             success (bool): 操作是否成功
-        
+
         异常情况：
             - 获取Cron状态失败：返回错误信息"获取Cron状态失败"
         """
-        data, success = self._request("GET", "/api/cron/status")
+        data, success = await self._request("GET", "/api/cron/status")
         if not success:
             return {}, False
         return data, True
 
-    def get_cron_tasks(self):
+    async def get_cron_tasks(self):
         """
-        获取已注册任务列表
-        
+        获取已注册任务列表（异步版本）
+
         功能说明：
             获取所有已注册的Cron任务列表。
-        
+
         输入参数：
             无
-        
+
         返回字段：
             data (dict): 任务列表信息
                 - tasks (list): 已注册的任务名称列表
                 - count (int): 任务数量
                 - timestamp (str): 获取时间
             success (bool): 操作是否成功
-        
+
         异常情况：
             - 获取任务列表失败：返回错误信息"获取任务列表失败"
         """
-        data, success = self._request("GET", "/api/cron/tasks")
+        data, success = await self._request("GET", "/api/cron/tasks")
         if not success:
             return {}, False
         return data, True
 
-    def get_cron_tasks_scheduled(self):
+    async def get_cron_tasks_scheduled(self):
         """
-        获取定时任务列表
-        
+        获取定时任务列表（异步版本）
+
         功能说明：
             获取所有配置的定时任务列表，包括任务详情、执行时间、状态等。
-        
+
         输入参数：
             无
-        
+
         返回字段：
             data (dict): 定时任务列表信息
                 - tasks (list): 定时任务列表
@@ -81,25 +81,25 @@ class CronManager(Client):
                 - count (int): 任务数量
                 - timestamp (str): 获取时间
             success (bool): 操作是否成功
-        
+
         异常情况：
             - 获取定时任务列表失败：返回错误信息"获取定时任务列表失败"
         """
-        data, success = self._request("GET", "/api/cron/tasks/scheduled")
+        data, success = await self._request("GET", "/api/cron/tasks/scheduled")
         if not success:
             return {}, False
         return data, True
 
-    def get_cron_tasks_detail(self, task_name: str):
+    async def get_cron_tasks_detail(self, task_name: str):
         """
-        获取任务详情
-        
+        获取任务详情（异步版本）
+
         功能说明：
             根据任务名称获取指定任务的详细信息。
-        
+
         输入参数：
             task_name (str): 任务名称，必填，需要URL编码
-        
+
         返回字段：
             data (dict): 任务详细信息
                 - task_name (str): 任务名称
@@ -112,28 +112,28 @@ class CronManager(Client):
                 - registration_info (dict): 注册信息
                 - timestamp (str): 获取时间
             success (bool): 操作是否成功
-        
+
         异常情况：
             - 任务不存在：返回错误信息"任务不存在"
             - 获取任务详情失败：返回错误信息"获取任务详情失败"
         """
-        data, success = self._request("GET", f"/api/cron/tasks/{task_name}")
+        data, success = await self._request("GET", f"/api/cron/tasks/{task_name}")
         if not success:
             return {}, False
         return data, True
 
-    def trigger_cron_task(self, task_name: str, args: list, kwargs: dict):
+    async def trigger_cron_task(self, task_name: str, args: list, kwargs: dict):
         """
-        触发任务执行
-        
+        触发任务执行（异步版本）
+
         功能说明：
             手动触发指定任务的执行，支持传递参数。
-        
+
         输入参数：
             task_name (str): 任务名称，必填，需要URL编码
             args (list): 任务参数列表，可选
             kwargs (dict): 任务关键字参数，可选
-        
+
         返回字段：
             data (dict): 任务触发信息
                 - task_id (str): 任务ID
@@ -141,12 +141,12 @@ class CronManager(Client):
                 - status (str): 任务状态，初始为"PENDING"
                 - message (str): 触发消息
             success (bool): 操作是否成功
-        
+
         异常情况：
             - 任务不存在：返回错误信息"任务不存在"
             - 任务触发失败：返回错误信息"任务触发失败"
         """
-        data, success = self._request(
+        data, success = await self._request(
             "POST",
             f"/api/cron/tasks/{task_name}/trigger",
             json={"args": args, "kwargs": kwargs},

pixelarraythirdparty/filestorage/__init__.py

@@ -0,0 +1,6 @@
+from pixelarraythirdparty.filestorage.filestorage import (
+    FileStorageManagerAsync,
+)
+
+__all__ = ["FileStorageManagerAsync"]
+

pixelarraythirdparty/filestorage/filestorage.py

@@ -0,0 +1,286 @@
+from pixelarraythirdparty.client import AsyncClient
+from typing import Dict, Any, Optional, List, Tuple, Callable, Union
+import os
+import asyncio
+import aiohttp
+import mimetypes
+
+
+class FileStorageManagerAsync(AsyncClient):
+    async def upload(
+        self, file_path: str, parent_id: Optional[int] = None
+    ) -> Tuple[bool, Dict[str, Any]]:
+        """
+        description:
+            上传文件（合并了初始化、分片上传、完成上传三个步骤）
+        parameters:
+            file_path: 文件路径（str）
+            parent_id: 父文件夹ID（可选）
+        return:
+            - data: 结果数据
+            - success: 是否成功
+        """
+        # 读取文件数据
+        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 = {
+            "filename": file_name,
+            "file_type": mime_type,
+            "total_size": total_size,
+        }
+        if parent_id is not None:
+            init_data["parent_id"] = parent_id
+
+        init_result, success = await self._request(
+            "POST", "/api/file_storage/upload/init", json=init_data
+        )
+        if not success:
+            return {}, False
+
+        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")
+
+            if not url or not part_number:
+                return None
+
+            # 使用预签名URL直接上传到OSS（PUT请求）
+            async with aiohttp.ClientSession() as session:
+                async with session.put(url, data=chunk_data) as resp:
+                    if resp.status == 200:
+                        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)
+        )
+
+        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,
+        }
+        complete_result, success = await self._request(
+            "POST", "/api/file_storage/upload/complete", json=complete_data
+        )
+        if not success:
+            return {}, False
+
+        return complete_result, True
+
+    async def list_files(
+        self,
+        parent_id: Optional[int] = None,
+        is_folder: Optional[bool] = None,
+        page: int = 1,
+        page_size: int = 50,
+    ) -> Tuple[List[Dict[str, Any]], bool]:
+        """
+        description:
+            获取文件列表
+        parameters:
+            parent_id: 父文件夹ID（可选）
+            is_folder: 是否只查询文件夹（可选）
+            page: 页码（可选）
+            page_size: 每页数量（可选）
+        return:
+            - data: 文件列表数据
+            - success: 是否成功
+        """
+        data = {
+            "page": page,
+            "page_size": page_size,
+        }
+        if parent_id is not None:
+            data["parent_id"] = parent_id
+        if is_folder is not None:
+            data["is_folder"] = is_folder
+
+        result, success = await self._request(
+            "POST", "/api/file_storage/files/list", json=data
+        )
+        if not success:
+            return {}, False
+        return result, True
+
+    async def create_folder(
+        self,
+        folder_name: str,
+        parent_id: Optional[int] = None,
+    ) -> Tuple[Dict[str, Any], bool]:
+        """
+        description:
+            创建文件夹
+        parameters:
+            folder_name: 文件夹名称
+            parent_id: 父文件夹ID（可选）
+        return:
+            - data: 文件夹数据
+            - success: 是否成功
+        """
+        data = {
+            "folder_name": folder_name,
+        }
+        if parent_id is not None:
+            data["parent_id"] = parent_id
+
+        data, success = await self._request(
+            "POST", "/api/file_storage/files/folder/create", json=data
+        )
+        if not success:
+            return {}, False
+        return data, True
+
+    async def delete_file(
+        self,
+        record_id: int,
+    ) -> Tuple[Dict[str, Any], bool]:
+        """
+        description:
+            删除文件或文件夹
+        parameters:
+            record_id: 文件或文件夹ID
+        return:
+            - data: 结果数据
+            - success: 是否成功
+        """
+        data, success = await self._request(
+            "DELETE", f"/api/file_storage/files/{record_id}"
+        )
+        if not success:
+            return {}, False
+        return data, True
+
+    async def get_folder_path(
+        self,
+        record_id: int,
+    ) -> Tuple[List[Dict[str, Any]], bool]:
+        """
+        description:
+            获取文件夹的完整路径
+        parameters:
+            record_id: 文件夹ID
+        return:
+            - data: 文件夹路径列表
+            - success: 是否成功
+        """
+        data, success = await self._request(
+            "GET", f"/api/file_storage/files/{record_id}/path"
+        )
+        if not success:
+            return [], False
+        # 如果data是字典，尝试获取data字段（因为API返回的是{"data": [...]}）
+        if isinstance(data, dict):
+            path_list = data.get("data", [])
+            if isinstance(path_list, list):
+                return path_list, True
+        # 如果data本身就是列表，直接返回
+        if isinstance(data, list):
+            return data, True
+        return [], False
+
+    async def generate_signed_url(
+        self,
+        record_id: int,
+        expires: int = 3600,
+    ) -> Tuple[Dict[str, Any], bool]:
+        """
+        生成签名URL（异步版本）
+        """
+        data = {
+            "expires": expires,
+        }
+        data, success = await self._request(
+            "POST", f"/api/file_storage/files/{record_id}/generate_url", json=data
+        )
+        if not success:
+            return {}, False
+        return data, True
+
+    async def download(
+        self,
+        record_id: int,
+        save_path: str,
+    ) -> Tuple[Dict[str, Any], bool]:
+        """
+        description:
+            下载文件
+        parameters:
+            record_id: 文件记录ID
+            save_path: 保存路径
+        return:
+            - data: 下载结果数据
+            - success: 是否成功
+        """
+        # 1. 生成签名URL
+        signed_url_data, success = await self.generate_signed_url(record_id)
+        if not success:
+            return {}, False
+
+        signed_url = signed_url_data.get("signed_url")
+        file_record = signed_url_data.get("file_record", {})
+        total_size = file_record.get("file_size", 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
+
+                async for chunk in resp.content.iter_chunked(8192):  # 8KB chunks
+                    file_data += chunk
+                    downloaded += len(chunk)
+
+                with open(save_path, "wb") as f:
+                    f.write(file_data)
+
+                return {"total_size": total_size, "success": True}, True