pixelarraythirdparty 1.1.9__tar.gz → 1.2.0__tar.gz

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

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

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

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

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

@@ -30,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"
         )
@@ -42,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:
@@ -77,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
 
@@ -99,19 +119,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 +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登录（手机端）
@@ -167,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:
@@ -197,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:
@@ -213,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
@@ -261,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"
         )
@@ -273,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:
@@ -293,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:
@@ -308,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
 
@@ -344,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"
         )
@@ -356,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:
@@ -376,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:
@@ -391,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
 
@@ -503,60 +583,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 +636,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 +650,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 +675,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 +728,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 +742,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.0}/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.0}/pixelarraythirdparty.egg-info/PKG-INFO

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

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

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