pixelarraythirdparty 1.1.7__tar.gz → 1.2.0__tar.gz

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/PKG-INFO

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

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/pixelarraythirdparty/__init__.py

@@ -13,7 +13,7 @@ PixelArray 第三方微服务客户端
 - project: 项目管理模块
 """
 
-__version__ = "1.1.7"
+__version__ = "1.2.0"
 __author__ = "Lu qi"
 __email__ = "qi.lu@pixelarrayai.com"
 

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/pixelarraythirdparty/client.py

@@ -4,6 +4,12 @@ from typing import Dict, Any, Tuple
 
 class AsyncClient:
     def __init__(self, api_key: str):
+        """
+        description:
+            初始化异步客户端
+        parameters:
+            api_key(str): API密钥，用于身份验证
+        """
         self.base_url = "https://thirdparty.pixelarrayai.com"
         self.api_key = api_key
         self.headers = {
@@ -14,6 +20,17 @@ class AsyncClient:
     async def _request(
         self, method: str, url: str, **kwargs
     ) -> Tuple[Dict[str, Any], bool]:
+        """
+        description:
+            发送异步HTTP请求的通用方法
+        parameters:
+            method(str): HTTP方法，如"GET"、"POST"、"PUT"、"DELETE"等
+            url(str): 请求URL路径（相对于base_url）
+            **kwargs: 其他请求参数，如json、params、headers等
+        return:
+            data(Dict[str, Any]): 响应数据字典，如果请求失败则返回空字典
+            success(bool): 请求是否成功
+        """
         # 如果kwargs中有headers，则合并headers
         headers = self.headers.copy()
         if "headers" in kwargs:
@@ -38,6 +55,17 @@ class AsyncClient:
     async def _request_raw(
         self, method: str, url: str, **kwargs
     ) -> Tuple[int, Dict[str, Any]]:
+        """
+        description:
+            发送异步HTTP请求的原始方法，返回完整的HTTP状态码和响应数据
+        parameters:
+            method(str): HTTP方法，如"GET"、"POST"、"PUT"、"DELETE"等
+            url(str): 请求URL路径（相对于base_url）
+            **kwargs: 其他请求参数，如json、params、headers等
+        return:
+            status_code(int): HTTP状态码
+            data(Dict[str, Any]): 响应数据字典，如果解析失败则返回空字典
+        """
         headers = self.headers.copy()
         if "headers" in kwargs:
             headers.update(kwargs["headers"])

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/pixelarraythirdparty/feedback/feedback.py

@@ -68,7 +68,14 @@ class FeedbackManagerAsync(AsyncClient):
         file_type: str,
     ):
         """
-        内部方法：上传文件到OSS
+        description:
+            内部方法：上传文件到OSS
+        parameters:
+            feedback_id(int): 反馈ID
+            file_data(Union[str, BinaryIO, bytes]): 文件数据，可以是文件路径、文件对象或字节数据
+            file_type(str): 文件类型，可选值："image"（图片）、"video"（视频）
+        return:
+            success(bool): 上传是否成功
         """
         # 读取文件数据
         file_content = None

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/pixelarraythirdparty/order/order.py

@@ -43,6 +43,39 @@ class OrderManagerAsync(AsyncClient):
             return {}, False
         return data, True
 
+    async def create_order_v2(
+        self,
+        product_id: str,
+        body: str = None,
+        remark: str = None,
+        payment_channel: str = "WECHAT",
+    ):
+        """
+        description:
+            创建订单并直接返回支付二维码（V2，推荐）。
+            相比旧流程（create_order + generate_qr_code），该接口一次请求完成下单和二维码链接生成。
+        parameters:
+            product_id(str): 产品ID
+            body(str): 商品描述
+            remark(str): 订单备注
+            payment_channel(str): 支付渠道，可选值："WECHAT"、"ALIPAY"、"PAYPAL"
+        return:
+            data(dict): 返回数据
+                - order(dict): 订单信息（字段同 create_order 返回）
+                - qr_code_url(str): 支付二维码图片URL
+            success(bool): 操作是否成功
+        """
+        data = {
+            "product_id": product_id,
+            "body": body,
+            "remark": remark,
+            "payment_channel": payment_channel,
+        }
+        data, success = await self._request("POST", "/api/orders/create_v2", json=data)
+        if not success:
+            return {}, False
+        return data, True
+
     async def list_order(
         self,
         page: int = 1,

pixelarraythirdparty-1.2.0/pixelarraythirdparty/unified_login/__init__.py

@@ -0,0 +1,20 @@
+from .unified_login import (
+    GoogleLogin,
+    WechatLogin,
+    GitHubLogin,
+    DouyinLogin,
+    GitLabLogin,
+    SMSLogin,
+    EmailLogin,
+)
+
+__all__ = [
+    "GoogleLogin",
+    "WechatLogin",
+    "GitHubLogin",
+    "DouyinLogin",
+    "GitLabLogin",
+    "SMSLogin",
+    "EmailLogin",
+]
+

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/pixelarraythirdparty/unified_login/unified_login.py

@@ -14,6 +14,15 @@ class GoogleLogin(AsyncClient):
     ```
     google = GoogleLogin(api_key="your_api_key")
     user_info, success = await google.login()
+    if success:
+        access_token = user_info.get("access_token")
+        refresh_token = user_info.get("refresh_token")
+        
+        # 使用refresh_token刷新access_token
+        if refresh_token:
+            token_data, success = await google.refresh_access_token(refresh_token)
+            if success:
+                new_access_token = token_data.get("access_token")
     ```
     """
 
@@ -21,6 +30,13 @@ class GoogleLogin(AsyncClient):
         super().__init__(api_key)
 
     async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+        """
+        description:
+            获取Google OAuth授权URL
+        return:
+            auth_data(dict, optional): 授权数据字典，包含auth_url和state
+            success(bool): 是否成功
+        """
         data, success = await self._request(
             "POST", "/api/unified-login/google/auth-url"
         )
@@ -33,10 +49,13 @@ class GoogleLogin(AsyncClient):
 
     async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
         """
-        仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，
-        终端端轮询等待登录结果
-
-        :param timeout: 等待用户完成授权的超时时间（秒）
+        description:
+            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
+        parameters:
+            timeout(int, optional): 等待用户完成授权的超时时间（秒），默认为180
+        return:
+            user_info(dict): 用户信息字典
+            success(bool): 是否成功
         """
         auth_data, success = await self._get_auth_url()
         if not success or not auth_data:
@@ -68,6 +87,16 @@ class GoogleLogin(AsyncClient):
     async def _wait_for_google_login(
         self, state: str, timeout: int
     ) -> Tuple[Dict, bool]:
+        """
+        description:
+            等待Google登录结果，轮询检查登录状态
+        parameters:
+            state(str): 登录状态标识
+            timeout(int): 超时时间（秒）
+        return:
+            user_info(dict): 用户信息字典
+            success(bool): 是否成功
+        """
         interval = 2
         total_checks = max(1, timeout // interval) if timeout > 0 else 1
 
@@ -88,6 +117,25 @@ class GoogleLogin(AsyncClient):
 
         return {}, False
 
+    async def refresh_access_token(self, refresh_token: str) -> Tuple[Dict, bool]:
+        """
+        description:
+            使用refresh_token刷新access_token
+        parameters:
+            refresh_token(str): Google OAuth refresh_token
+        return:
+            token_data(dict): 包含新的access_token和可能的refresh_token的字典
+            success(bool): 是否成功
+        """
+        data, success = await self._request(
+            "POST",
+            "/api/unified-login/google/refresh-token",
+            json={"refresh_token": refresh_token},
+        )
+        if not success:
+            return {}, False
+        return data, True
+
 
 class WechatLogin(AsyncClient):
     """
@@ -112,9 +160,13 @@ class WechatLogin(AsyncClient):
 
     async def _get_auth_url(self, login_type: str = "desktop") -> Tuple[Optional[Dict[str, str]], bool]:
         """
-        获取微信授权URL
-        
-        :param login_type: 登录类型，desktop 表示PC端扫码登录，mobile 表示微信公众号登录
+        description:
+            获取微信授权URL
+        parameters:
+            login_type(str, optional): 登录类型，desktop表示PC端扫码登录，mobile表示微信公众号登录，默认为desktop
+        return:
+            auth_data(dict, optional): 授权数据字典，包含auth_url和state
+            success(bool): 是否成功
         """
         if login_type == "mobile":
             # 微信公众号OAuth登录（手机端）
@@ -133,20 +185,14 @@ class WechatLogin(AsyncClient):
 
     async def login(self, login_type: str = "desktop", timeout: int = 180) -> Tuple[Dict, bool]:
         """
-        仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，
-        终端端轮询等待登录结果
-
-        :param login_type: 登录类型，desktop 表示PC端扫码登录，mobile 表示微信公众号登录
-        :param timeout: 等待用户完成授权的超时时间（秒）
-        
-        使用示例:
-        ```
-        wechat = WechatLogin(api_key="your_api_key")
-        # PC端扫码登录
-        user_info, success = await wechat.login(login_type="desktop")
-        # 微信公众号登录（手机端）
-        user_info, success = await wechat.login(login_type="mobile")
-        ```
+        description:
+            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
+        parameters:
+            login_type(str, optional): 登录类型，desktop表示PC端扫码登录，mobile表示微信公众号登录，默认为desktop
+            timeout(int, optional): 等待用户完成授权的超时时间（秒），默认为180
+        return:
+            user_info(dict): 用户信息字典
+            success(bool): 是否成功
         """
         auth_data, success = await self._get_auth_url(login_type)
         if not success or not auth_data:
@@ -163,6 +209,14 @@ class WechatLogin(AsyncClient):
         return await self._wait_for_wechat_login(state, timeout, login_type)
 
     def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
+        """
+        description:
+            从授权URL中提取state参数
+        parameters:
+            auth_url(str, optional): 授权URL
+        return:
+            state(str, optional): state参数值，如果提取失败则返回None
+        """
         if not auth_url:
             return None
         try:
@@ -179,11 +233,15 @@ class WechatLogin(AsyncClient):
         self, state: str, timeout: int, login_type: str = "desktop"
     ) -> Tuple[Dict, bool]:
         """
-        等待微信登录结果
-        
-        :param state: 登录状态标识
-        :param timeout: 超时时间（秒）
-        :param login_type: 登录类型，desktop 表示PC端扫码登录，mobile 表示微信公众号登录
+        description:
+            等待微信登录结果，轮询检查登录状态
+        parameters:
+            state(str): 登录状态标识
+            timeout(int): 超时时间（秒）
+            login_type(str, optional): 登录类型，desktop表示PC端扫码登录，mobile表示微信公众号登录，默认为desktop
+        return:
+            user_info(dict): 用户信息字典
+            success(bool): 是否成功
         """
         interval = 2
         total_checks = max(1, timeout // interval) if timeout > 0 else 1
@@ -227,6 +285,13 @@ class GitHubLogin(AsyncClient):
         super().__init__(api_key)
 
     async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+        """
+        description:
+            获取GitHub OAuth授权URL
+        return:
+            auth_data(dict, optional): 授权数据字典，包含auth_url和state
+            success(bool): 是否成功
+        """
         data, success = await self._request(
             "POST", "/api/unified-login/github/auth-url"
         )
@@ -239,10 +304,13 @@ class GitHubLogin(AsyncClient):
 
     async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
         """
-        仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，
-        终端端轮询等待登录结果
-
-        :param timeout: 等待用户完成授权的超时时间（秒）
+        description:
+            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
+        parameters:
+            timeout(int, optional): 等待用户完成授权的超时时间（秒），默认为180
+        return:
+            user_info(dict): 用户信息字典
+            success(bool): 是否成功
         """
         auth_data, success = await self._get_auth_url()
         if not success or not auth_data:
@@ -259,6 +327,14 @@ class GitHubLogin(AsyncClient):
         return await self._wait_for_github_login(state, timeout)
 
     def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
+        """
+        description:
+            从授权URL中提取state参数
+        parameters:
+            auth_url(str, optional): 授权URL
+        return:
+            state(str, optional): state参数值，如果提取失败则返回None
+        """
         if not auth_url:
             return None
         try:
@@ -274,6 +350,16 @@ class GitHubLogin(AsyncClient):
     async def _wait_for_github_login(
         self, state: str, timeout: int
     ) -> Tuple[Dict, bool]:
+        """
+        description:
+            等待GitHub登录结果，轮询检查登录状态
+        parameters:
+            state(str): 登录状态标识
+            timeout(int): 超时时间（秒）
+        return:
+            user_info(dict): 用户信息字典
+            success(bool): 是否成功
+        """
         interval = 2
         total_checks = max(1, timeout // interval) if timeout > 0 else 1
 
@@ -310,6 +396,13 @@ class DouyinLogin(AsyncClient):
         super().__init__(api_key)
 
     async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+        """
+        description:
+            获取抖音OAuth授权URL
+        return:
+            auth_data(dict, optional): 授权数据字典，包含auth_url和state
+            success(bool): 是否成功
+        """
         data, success = await self._request(
             "POST", "/api/unified-login/douyin/auth-url"
         )
@@ -322,10 +415,13 @@ class DouyinLogin(AsyncClient):
 
     async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
         """
-        仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，
-        终端端轮询等待登录结果
-
-        :param timeout: 等待用户完成授权的超时时间（秒）
+        description:
+            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
+        parameters:
+            timeout(int, optional): 等待用户完成授权的超时时间（秒），默认为180
+        return:
+            user_info(dict): 用户信息字典
+            success(bool): 是否成功
         """
         auth_data, success = await self._get_auth_url()
         if not success or not auth_data:
@@ -342,6 +438,14 @@ class DouyinLogin(AsyncClient):
         return await self._wait_for_douyin_login(state, timeout)
 
     def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
+        """
+        description:
+            从授权URL中提取state参数
+        parameters:
+            auth_url(str, optional): 授权URL
+        return:
+            state(str, optional): state参数值，如果提取失败则返回None
+        """
         if not auth_url:
             return None
         try:
@@ -357,6 +461,16 @@ class DouyinLogin(AsyncClient):
     async def _wait_for_douyin_login(
         self, state: str, timeout: int
     ) -> Tuple[Dict, bool]:
+        """
+        description:
+            等待抖音登录结果，轮询检查登录状态
+        parameters:
+            state(str): 登录状态标识
+            timeout(int): 超时时间（秒）
+        return:
+            user_info(dict): 用户信息字典
+            success(bool): 是否成功
+        """
         interval = 2
         total_checks = max(1, timeout // interval) if timeout > 0 else 1
 
@@ -459,3 +573,187 @@ class GitLabLogin(AsyncClient):
             await asyncio.sleep(interval)
 
         return {}, False
+
+
+class SMSLogin(AsyncClient):
+    """
+    短信验证码登录客户端
+
+    使用示例:
+    ```
+    sms = SMSLogin(api_key="your_api_key")
+    # 发送验证码
+    success = await sms.send_code(phone="13800138000")
+    if success:
+        # 验证验证码并登录
+        user_info, success = await sms.login(phone="13800138000", code="123456")
+    ```
+    """
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key)
+
+    async def send_code(self, phone: str) -> bool:
+        """
+        发送短信验证码
+
+        :param phone: 手机号码
+        :return: success 是否成功
+        """
+        data, success = await self._request(
+            "POST", "/api/unified-login/sms/send-code", json={"phone": phone}
+        )
+        return bool(success)
+
+    async def verify_code(self, phone: str, code: str) -> bool:
+        """
+        验证短信验证码
+
+        :param phone: 手机号码
+        :param code: 验证码
+        :return: success 是否成功
+        """
+        _, success = await self._request(
+            "POST",
+            "/api/unified-login/sms/verify-code",
+            json={"phone": phone, "code": code},
+        )
+        return bool(success)
+
+    async def _wait_for_login(
+        self, phone: str, timeout: int
+    ) -> Tuple[Dict, bool]:
+        """
+        等待短信登录结果
+
+        :param phone: 手机号码
+        :param timeout: 超时时间（秒）
+        """
+        interval = 2
+        total_checks = max(1, timeout // interval) if timeout > 0 else 1
+
+        for _ in range(total_checks):
+            status, response = await self._request_raw(
+                "POST",
+                "/api/unified-login/sms/wait-sms-login",
+                json={"phone": phone},
+            )
+
+            if status == 200 and response.get("success") is True:
+                return response.get("data", {}), True
+
+            if status in (400, 408):
+                break
+
+            await asyncio.sleep(interval)
+
+        return {}, False
+
+    async def login(
+        self, phone: str, code: str, timeout: int = 180
+    ) -> Tuple[Dict, bool]:
+        """
+        验证验证码并等待登录结果
+
+        :param phone: 手机号码
+        :param code: 验证码
+        :param timeout: 等待登录结果的超时时间（秒）
+        :return: (用户信息, 是否成功)
+        """
+        success = await self.verify_code(phone, code)
+        if not success:
+            return {}, False
+
+        return await self._wait_for_login(phone, timeout)
+
+
+class EmailLogin(AsyncClient):
+    """
+    邮箱验证码登录客户端
+
+    使用示例:
+    ```
+    email = EmailLogin(api_key="your_api_key")
+    # 发送验证码
+    success = await email.send_code(email="user@example.com")
+    if success:
+        # 验证验证码并登录
+        user_info, success = await email.login(email="user@example.com", code="123456")
+    ```
+    """
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key)
+
+    async def send_code(self, email: str) -> bool:
+        """
+        发送邮箱验证码
+
+        :param email: 邮箱地址
+        :return: success 是否成功
+        """
+        _, success = await self._request(
+            "POST", "/api/unified-login/email/send-code", json={"email": email}
+        )
+        return bool(success)
+
+    async def verify_code(self, email: str, code: str) -> bool:
+        """
+        验证邮箱验证码
+
+        :param email: 邮箱地址
+        :param code: 验证码
+        :return: success 是否成功
+        """
+        _, success = await self._request(
+            "POST",
+            "/api/unified-login/email/verify-code",
+            json={"email": email, "code": code},
+        )
+        return bool(success)
+
+    async def _wait_for_login(
+        self, email: str, timeout: int
+    ) -> Tuple[Dict, bool]:
+        """
+        等待邮箱登录结果
+
+        :param email: 邮箱地址
+        :param timeout: 超时时间（秒）
+        """
+        interval = 2
+        total_checks = max(1, timeout // interval) if timeout > 0 else 1
+
+        for _ in range(total_checks):
+            status, response = await self._request_raw(
+                "POST",
+                "/api/unified-login/email/wait-email-login",
+                json={"email": email},
+            )
+
+            if status == 200 and response.get("success") is True:
+                return response.get("data", {}), True
+
+            if status in (400, 408):
+                break
+
+            await asyncio.sleep(interval)
+
+        return {}, False
+
+    async def login(
+        self, email: str, code: str, timeout: int = 180
+    ) -> Tuple[Dict, bool]:
+        """
+        验证验证码并等待登录结果
+
+        :param email: 邮箱地址
+        :param code: 验证码
+        :param timeout: 等待登录结果的超时时间（秒）
+        :return: (用户信息, 是否成功)
+        """
+        success = await self.verify_code(email, code)
+        if not success:
+            return {}, False
+
+        return await self._wait_for_login(email, timeout)

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/pixelarraythirdparty/user/user.py

@@ -73,9 +73,6 @@ class UserManagerAsync(AsyncClient):
         """
         description:
             更新指定用户的信息，包括用户名、邮箱、角色和状态。仅管理员可访问。
-
-        功能说明：
-            更新指定用户的信息，包括用户名、邮箱、角色和状态。仅管理员可访问。
         parameters:
             user_id(int): 用户ID
             username(str): 用户名

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/pixelarraythirdparty.egg-info/PKG-INFO

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

{pixelarraythirdparty-1.1.7 → pixelarraythirdparty-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pixelarraythirdparty"
-version = "1.1.7"
+version = "1.2.0"
 authors = [
     {name = "Lu qi", email = "qi.lu@pixelarrayai.com"},
 ]

pixelarraythirdparty-1.1.7/pixelarraythirdparty/unified_login/__init__.py

@@ -1,4 +0,0 @@
-from .unified_login import GoogleLogin, WechatLogin, GitHubLogin
-
-__all__ = ["GoogleLogin", "WechatLogin", "GitHubLogin"]
-