pixelarraythirdparty 1.1.9__tar.gz → 1.2.1__tar.gz

{pixelarraythirdparty-1.1.9 → pixelarraythirdparty-1.2.1}/PKG-INFO

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

{pixelarraythirdparty-1.1.9 → pixelarraythirdparty-1.2.1}/pixelarraythirdparty/__init__.py

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

{pixelarraythirdparty-1.1.9 → pixelarraythirdparty-1.2.1}/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.9 → pixelarraythirdparty-1.2.1}/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.9 → pixelarraythirdparty-1.2.1}/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.1.9 → pixelarraythirdparty-1.2.1}/pixelarraythirdparty/unified_login/__init__.py

@@ -1,4 +1,5 @@
 from .unified_login import (
+    OAuth2Login,
     GoogleLogin,
     WechatLogin,
     GitHubLogin,
@@ -9,6 +10,7 @@ from .unified_login import (
 )
 
 __all__ = [
+    "OAuth2Login",
     "GoogleLogin",
     "WechatLogin",
     "GitHubLogin",

{pixelarraythirdparty-1.1.9 → pixelarraythirdparty-1.2.1}/pixelarraythirdparty/unified_login/unified_login.py

@@ -6,6 +6,244 @@ from typing import Dict, Optional, Tuple
 from pixelarraythirdparty.client import AsyncClient
 
 
+class OAuth2Login(AsyncClient):
+    """
+    统一的 OAuth2 登录客户端基类
+    
+    支持所有基于 OAuth2 的第三方登录（Google、微信、GitHub、GitLab、抖音等）
+    通过配置不同的端点来支持不同的提供商
+    
+    使用示例:
+    ```
+    # Google登录
+    google = OAuth2Login(
+        api_key="your_api_key",
+        provider="google"
+    )
+    user_info, success = await google.login()
+    
+    # 微信PC端扫码登录
+    wechat = OAuth2Login(
+        api_key="your_api_key",
+        provider="wechat",
+        login_type="desktop"
+    )
+    user_info, success = await wechat.login()
+    
+    # 微信手机端登录
+    wechat_mobile = OAuth2Login(
+        api_key="your_api_key",
+        provider="wechat",
+        login_type="mobile"
+    )
+    user_info, success = await wechat_mobile.login()
+    
+    # 支持refresh_token的提供商（如Google、GitLab）
+    if user_info.get("refresh_token"):
+        token_data, success = await google.refresh_access_token(
+            user_info.get("refresh_token")
+        )
+    ```
+    """
+    
+    # 提供商端点映射
+    PROVIDER_ENDPOINTS = {
+        "google": {
+            "auth_url": "/api/unified-login/google/auth-url",
+            "wait_login": "/api/unified-login/google/wait-login",
+            "refresh_token": "/api/unified-login/google/refresh-token",
+        },
+        "wechat": {
+            "auth_url": "/api/unified-login/wechat/auth-url",
+            "wait_login": "/api/unified-login/wechat/wait-login",
+        },
+        "wechat-official": {
+            "auth_url": "/api/unified-login/wechat-official/auth-url",
+            "wait_login": "/api/unified-login/wechat-official/wait-login",
+        },
+        "github": {
+            "auth_url": "/api/unified-login/github/auth-url",
+            "wait_login": "/api/unified-login/github/wait-login",
+        },
+        "gitlab": {
+            "auth_url": "/api/unified-login/gitlab/auth-url",
+            "wait_login": "/api/unified-login/gitlab/wait-login",
+            "refresh_token": "/api/unified-login/gitlab/refresh-token",
+        },
+        "douyin": {
+            "auth_url": "/api/unified-login/douyin/auth-url",
+            "wait_login": "/api/unified-login/douyin/wait-login",
+        },
+    }
+    
+    def __init__(
+        self,
+        api_key: str,
+        provider: str,
+        login_type: Optional[str] = None
+    ):
+        """
+        description:
+            初始化OAuth2登录客户端
+        parameters:
+            api_key(str): API密钥
+            provider(str): 提供商名称，可选值：google, wechat, github, gitlab, douyin
+            login_type(str, optional): 登录类型，仅对微信有效，可选值：desktop（PC端扫码）, mobile（手机端）
+        """
+        super().__init__(api_key)
+        self.provider = provider.lower()
+        self.login_type = login_type
+        
+        # 验证提供商是否支持
+        if self.provider not in self.PROVIDER_ENDPOINTS:
+            raise ValueError(
+                f"不支持的提供商: {provider}。"
+                f"支持的提供商: {', '.join(self.PROVIDER_ENDPOINTS.keys())}"
+            )
+        
+        # 微信特殊处理：根据login_type选择不同的端点
+        if self.provider == "wechat":
+            if login_type == "mobile":
+                self.provider = "wechat-official"
+    
+    def _get_endpoint(self, endpoint_type: str) -> str:
+        """
+        description:
+            获取指定类型的端点URL
+        parameters:
+            endpoint_type(str): 端点类型，可选值：auth_url, wait_login, refresh_token
+        return:
+            endpoint(str): 端点URL
+        """
+        endpoints = self.PROVIDER_ENDPOINTS.get(self.provider, {})
+        endpoint = endpoints.get(endpoint_type)
+        if not endpoint:
+            raise ValueError(
+                f"提供商 {self.provider} 不支持 {endpoint_type} 端点"
+            )
+        return endpoint
+    
+    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): 是否成功
+        """
+        endpoint = self._get_endpoint("auth_url")
+        data, success = await self._request("POST", endpoint)
+        if not success:
+            return None, False
+        auth_url = data.get("auth_url")
+        if not auth_url:
+            return None, False
+        return data, True
+    
+    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:
+            parsed = urllib.parse.urlparse(auth_url)
+            query = urllib.parse.parse_qs(parsed.query)
+            values = query.get("state")
+            if values:
+                return values[0]
+        except Exception:
+            return None
+        return None
+    
+    async def _wait_for_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
+        endpoint = self._get_endpoint("wait_login")
+        
+        for _ in range(total_checks):
+            status, response = await self._request_raw(
+                "POST",
+                endpoint,
+                json={"state": state},
+            )
+            
+            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, timeout: int = 180) -> Tuple[Dict, bool]:
+        """
+        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:
+            return {}, False
+        
+        auth_url = auth_data.get("auth_url")
+        state = auth_data.get("state") or self._extract_state(auth_url)
+        
+        if not auth_url or not state:
+            return {}, False
+        
+        webbrowser.open(auth_url, new=2)
+        
+        return await self._wait_for_login(state, timeout)
+    
+    async def refresh_access_token(self, refresh_token: str) -> Tuple[Dict, bool]:
+        """
+        description:
+            使用refresh_token刷新access_token（仅支持Google和GitLab）
+        parameters:
+            refresh_token(str): OAuth refresh_token
+        return:
+            token_data(dict): 包含新的access_token和可能的refresh_token的字典
+            success(bool): 是否成功
+        """
+        try:
+            endpoint = self._get_endpoint("refresh_token")
+        except ValueError:
+            return {}, False
+        
+        data, success = await self._request(
+            "POST",
+            endpoint,
+            json={"refresh_token": refresh_token},
+        )
+        if not success:
+            return {}, False
+        return data, True
+
+
 class GoogleLogin(AsyncClient):
     """
     Google OAuth2 登录客户端
@@ -30,6 +268,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"
         )
@@ -42,10 +287,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:
@@ -77,6 +325,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
 
@@ -99,19 +357,13 @@ class GoogleLogin(AsyncClient):
 
     async def refresh_access_token(self, refresh_token: str) -> Tuple[Dict, bool]:
         """
-        使用refresh_token刷新access_token
-        
-        :param refresh_token: Google OAuth refresh_token
-        :return: 包含新的access_token和可能的refresh_token的字典，以及是否成功的布尔值
-        
-        使用示例:
-        ```
-        google = GoogleLogin(api_key="your_api_key")
-        token_data, success = await google.refresh_access_token(refresh_token="your_refresh_token")
-        if success:
-            new_access_token = token_data.get("access_token")
-            new_refresh_token = token_data.get("refresh_token")  # 可能为None
-        ```
+        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",
@@ -146,9 +398,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登录（手机端）
@@ -167,20 +423,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:
@@ -197,6 +447,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:
@@ -213,11 +471,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
@@ -261,6 +523,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"
         )
@@ -273,10 +542,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:
@@ -293,6 +565,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:
@@ -308,6 +588,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
 
@@ -344,6 +634,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"
         )
@@ -356,10 +653,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:
@@ -376,6 +676,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:
@@ -391,6 +699,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
 
@@ -494,6 +812,25 @@ class GitLabLogin(AsyncClient):
 
         return {}, False
 
+    async def refresh_access_token(self, refresh_token: str) -> Tuple[Dict, bool]:
+        """
+        description:
+            使用refresh_token刷新access_token
+        parameters:
+            refresh_token(str): GitLab OAuth refresh_token
+        return:
+            token_data(dict): 包含新的access_token和可能的refresh_token的字典
+            success(bool): 是否成功
+        """
+        data, success = await self._request(
+            "POST",
+            "/api/unified-login/gitlab/refresh-token",
+            json={"refresh_token": refresh_token},
+        )
+        if not success:
+            return {}, False
+        return data, True
+
 
 class SMSLogin(AsyncClient):
     """
@@ -503,60 +840,50 @@ class SMSLogin(AsyncClient):
     ```
     sms = SMSLogin(api_key="your_api_key")
     # 发送验证码
-    state, success = await sms.send_code(phone="13800138000")
+    success = await sms.send_code(phone="13800138000")
     if success:
         # 验证验证码并登录
-        user_info, success = await sms.login(state=state, code="123456")
+        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) -> Tuple[Optional[str], bool]:
+    async def send_code(self, phone: str) -> bool:
         """
         发送短信验证码
 
         :param phone: 手机号码
-        :return: (state, success) state用于后续验证验证码
+        :return: success 是否成功
         """
         data, success = await self._request(
             "POST", "/api/unified-login/sms/send-code", json={"phone": phone}
         )
-        if not success:
-            return None, False
-        state = data.get("state")
-        if not state:
-            return None, False
-        return state, True
+        return bool(success)
 
-    async def verify_code(self, state: str, code: str) -> Tuple[Optional[str], bool]:
+    async def verify_code(self, phone: str, code: str) -> bool:
         """
         验证短信验证码
 
-        :param state: 发送验证码时返回的state
+        :param phone: 手机号码
         :param code: 验证码
-        :return: (state, success) state用于后续等待登录结果
+        :return: success 是否成功
         """
-        data, success = await self._request(
+        _, success = await self._request(
             "POST",
             "/api/unified-login/sms/verify-code",
-            json={"state": state, "code": code},
+            json={"phone": phone, "code": code},
         )
-        if not success:
-            return None, False
-        new_state = data.get("state")
-        if not new_state:
-            return None, False
-        return new_state, True
+        return bool(success)
 
     async def _wait_for_login(
-        self, state: str, timeout: int
+        self, phone: str, timeout: int
     ) -> Tuple[Dict, bool]:
         """
         等待短信登录结果
 
-        :param state: 验证验证码时返回的state
+        :param phone: 手机号码
         :param timeout: 超时时间（秒）
         """
         interval = 2
@@ -566,7 +893,7 @@ class SMSLogin(AsyncClient):
             status, response = await self._request_raw(
                 "POST",
                 "/api/unified-login/sms/wait-sms-login",
-                json={"state": state},
+                json={"phone": phone},
             )
 
             if status == 200 and response.get("success") is True:
@@ -580,21 +907,21 @@ class SMSLogin(AsyncClient):
         return {}, False
 
     async def login(
-        self, state: str, code: str, timeout: int = 180
+        self, phone: str, code: str, timeout: int = 180
     ) -> Tuple[Dict, bool]:
         """
         验证验证码并等待登录结果
 
-        :param state: 发送验证码时返回的state
+        :param phone: 手机号码
         :param code: 验证码
         :param timeout: 等待登录结果的超时时间（秒）
         :return: (用户信息, 是否成功)
         """
-        new_state, success = await self.verify_code(state, code)
-        if not success or not new_state:
+        success = await self.verify_code(phone, code)
+        if not success:
             return {}, False
 
-        return await self._wait_for_login(new_state, timeout)
+        return await self._wait_for_login(phone, timeout)
 
 
 class EmailLogin(AsyncClient):
@@ -605,60 +932,50 @@ class EmailLogin(AsyncClient):
     ```
     email = EmailLogin(api_key="your_api_key")
     # 发送验证码
-    state, success = await email.send_code(email="user@example.com")
+    success = await email.send_code(email="user@example.com")
     if success:
         # 验证验证码并登录
-        user_info, success = await email.login(state=state, code="123456")
+        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) -> Tuple[Optional[str], bool]:
+    async def send_code(self, email: str) -> bool:
         """
         发送邮箱验证码
 
         :param email: 邮箱地址
-        :return: (state, success) state用于后续验证验证码
+        :return: success 是否成功
         """
-        data, success = await self._request(
+        _, success = await self._request(
             "POST", "/api/unified-login/email/send-code", json={"email": email}
         )
-        if not success:
-            return None, False
-        state = data.get("state")
-        if not state:
-            return None, False
-        return state, True
+        return bool(success)
 
-    async def verify_code(self, state: str, code: str) -> Tuple[Optional[str], bool]:
+    async def verify_code(self, email: str, code: str) -> bool:
         """
         验证邮箱验证码
 
-        :param state: 发送验证码时返回的state
+        :param email: 邮箱地址
         :param code: 验证码
-        :return: (state, success) state用于后续等待登录结果
+        :return: success 是否成功
         """
-        data, success = await self._request(
+        _, success = await self._request(
             "POST",
             "/api/unified-login/email/verify-code",
-            json={"state": state, "code": code},
+            json={"email": email, "code": code},
         )
-        if not success:
-            return None, False
-        new_state = data.get("state")
-        if not new_state:
-            return None, False
-        return new_state, True
+        return bool(success)
 
     async def _wait_for_login(
-        self, state: str, timeout: int
+        self, email: str, timeout: int
     ) -> Tuple[Dict, bool]:
         """
         等待邮箱登录结果
 
-        :param state: 验证验证码时返回的state
+        :param email: 邮箱地址
         :param timeout: 超时时间（秒）
         """
         interval = 2
@@ -668,7 +985,7 @@ class EmailLogin(AsyncClient):
             status, response = await self._request_raw(
                 "POST",
                 "/api/unified-login/email/wait-email-login",
-                json={"state": state},
+                json={"email": email},
             )
 
             if status == 200 and response.get("success") is True:
@@ -682,18 +999,18 @@ class EmailLogin(AsyncClient):
         return {}, False
 
     async def login(
-        self, state: str, code: str, timeout: int = 180
+        self, email: str, code: str, timeout: int = 180
     ) -> Tuple[Dict, bool]:
         """
         验证验证码并等待登录结果
 
-        :param state: 发送验证码时返回的state
+        :param email: 邮箱地址
         :param code: 验证码
         :param timeout: 等待登录结果的超时时间（秒）
         :return: (用户信息, 是否成功)
         """
-        new_state, success = await self.verify_code(state, code)
-        if not success or not new_state:
+        success = await self.verify_code(email, code)
+        if not success:
             return {}, False
 
-        return await self._wait_for_login(new_state, timeout)
+        return await self._wait_for_login(email, timeout)

{pixelarraythirdparty-1.1.9 → pixelarraythirdparty-1.2.1}/pixelarraythirdparty/user/user.py

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

{pixelarraythirdparty-1.1.9 → pixelarraythirdparty-1.2.1}/pixelarraythirdparty.egg-info/PKG-INFO

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

{pixelarraythirdparty-1.1.9 → pixelarraythirdparty-1.2.1}/pyproject.toml

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