pixelarraythirdparty 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

pixelarraythirdparty/__init__.py

@@ -6,13 +6,11 @@ PixelArray 第三方微服务客户端
 这个库包含了常用的开发工具和服务集成：
 - order: 订单管理模块和支付模块
 - product: 产品管理模块
-- cron: 定时任务管理模块
 - user: 用户管理模块
 - unified_login: 统一登录模块
 - feedback: 客户反馈模块
 - project: 项目管理模块
 - support_chat: 在线客服（临时会话链接）
-- custom_events: 自定义事件（新建定义、上报与报表查询）
 - project_dashboard: 项目看板（按 scope 查询 DNU/DAU/留存）
 """
 
@@ -21,27 +19,23 @@ from .support_chat.support_chat import (
     SupportChatManagerAsync,
     build_staff_portal_session_url,
 )
-from .custom_events.custom_events import CustomEventsManagerAsync
 from .project_dashboard.project_dashboard import ProjectDashboardManagerAsync
 
-__version__ = "1.3.7"
+__version__ = "1.3.9"
 __author__ = "Lu qi"
 __email__ = "qi.lu@pixelarrayai.com"
 
 # 导出主要模块
 __all__ = [
     "product",
-    "cron",
     "user",
     "order",
     "feedback",
     "project",
     "support_chat",
-    "custom_events",
     "project_dashboard",
     "FeedbackManagerAsync",
     "SupportChatManagerAsync",
     "build_staff_portal_session_url",
-    "CustomEventsManagerAsync",
     "ProjectDashboardManagerAsync",
 ]

pixelarraythirdparty/client.py

@@ -10,7 +10,7 @@ class AsyncClient:
         parameters:
             api_key(str): API密钥，用于身份验证
         """
-        self.base_url = "https://thirdparty.pixelarrayai.com"
+        self.base_url = "https://thirdparty.arraypixelai.com"
         self.api_key = api_key
         self.headers = {
             "Content-Type": "application/json",

pixelarraythirdparty/order/order.py

@@ -1,3 +1,34 @@
+"""
+订单与支付客户端。
+
+商户业务回调（callback_url）
+--------------------------------
+创建订单时传入 ``callback_url``（http/https）后，支付成功或退款成功时，
+本服务会向该地址 **POST** ``Content-Type: application/json``，Body 结构如下。
+
+公共字段（两种事件均包含）::
+
+    event (str): "order.paid" 或 "order.refunded"
+    out_trade_no (str): 商户订单号
+    payment_status (str): "PAID" 或 "REFUNDED"
+    payment_channel (str): "WECHAT" | "ALIPAY"
+    product_id (str|None): 产品 ID
+    amount (float|None): 订单金额（元）
+    total_fee (int|None): 订单金额（分）
+    transaction_id (str|None): 渠道交易号
+    timestamp (str): 回调发送时刻，ISO 8601 UTC
+
+支付成功（event="order.paid"）额外字段::
+
+    paid_at (str|None): 支付时间
+
+退款成功（event="order.refunded"）额外字段::
+
+    refunded_at (str|None): 退款时间
+
+幂等：同一状态重复通知不会重复回调。失败时服务端最多重试 2 次（间隔 1 秒）。
+业务方接口应返回 HTTP 2xx 表示接收成功。
+"""
 from pixelarraythirdparty.client import AsyncClient
 
 
@@ -9,6 +40,7 @@ class OrderManagerAsync(AsyncClient):
         remark: str = None,
         payment_channel: str = "WECHAT",
         amount_yuan: float = None,
+        callback_url: str = None,
     ):
         """
         description:
@@ -19,6 +51,9 @@ class OrderManagerAsync(AsyncClient):
             remark(str): 订单备注
             payment_channel(str): 支付渠道，可选值："WECHAT"（微信支付）、"ALIPAY"（支付宝支付）
             amount_yuan(float, optional): 订单金额（元），可变金额产品必填
+            callback_url(str, optional): 支付/退款结果业务回调地址（http/https）。
+                支付/退款成功后服务端 POST JSON 至该地址，Body 字段见本模块顶部
+                「商户业务回调（callback_url）」说明。
         return:
             data(dict): 订单信息
                 - id(int): 订单ID
@@ -30,6 +65,7 @@ class OrderManagerAsync(AsyncClient):
                 - total_fee(int): 订单金额（分），用于支付接口
                 - body(str): 商品描述
                 - remark(str): 订单备注
+                - callback_url(str, optional): 商户业务回调地址
                 - created_at(str): 订单创建时间
                 - updated_at(str): 订单更新时间
             success(bool): 操作是否成功
@@ -42,6 +78,8 @@ class OrderManagerAsync(AsyncClient):
         }
         if amount_yuan is not None:
             data["amount_yuan"] = amount_yuan
+        if callback_url is not None:
+            data["callback_url"] = callback_url
         data, success = await self._request("POST", "/api/orders/create", json=data)
         if not success:
             return data, False
@@ -54,6 +92,7 @@ class OrderManagerAsync(AsyncClient):
         remark: str = None,
         payment_channel: str = "WECHAT",
         amount_yuan: float = None,
+        callback_url: str = None,
     ):
         """
         description:
@@ -63,8 +102,10 @@ class OrderManagerAsync(AsyncClient):
             product_id(str): 产品ID
             body(str): 商品描述
             remark(str): 订单备注
-            payment_channel(str): 支付渠道，可选值："WECHAT"、"ALIPAY"、"PAYPAL"
+            payment_channel(str): 支付渠道，可选值："WECHAT"、"ALIPAY"
             amount_yuan(float, optional): 订单金额（元），可变金额产品必填
+            callback_url(str, optional): 支付/退款结果业务回调地址（http/https）。
+                回调 POST Body 结构见本模块顶部「商户业务回调（callback_url）」说明。
         return:
             data(dict): 返回数据
                 - order(dict): 订单信息（字段同 create_order 返回）
@@ -79,6 +120,8 @@ class OrderManagerAsync(AsyncClient):
         }
         if amount_yuan is not None:
             data["amount_yuan"] = amount_yuan
+        if callback_url is not None:
+            data["callback_url"] = callback_url
         data, success = await self._request("POST", "/api/orders/create_v2", json=data)
         if not success:
             return data, False

pixelarraythirdparty/unified_login/__init__.py

@@ -1,26 +1,11 @@
 from .unified_login import (
     OAuth2Login,
-    GoogleLogin,
     WechatLogin,
-    GitHubLogin,
     DouyinLogin,
-    TiktokLogin,
-    GitLabLogin,
-    SMSLogin,
-    EmailLogin,
-    PasswordLogin,
 )
 
 __all__ = [
     "OAuth2Login",
-    "GoogleLogin",
     "WechatLogin",
-    "GitHubLogin",
     "DouyinLogin",
-    "TiktokLogin",
-    "GitLabLogin",
-    "SMSLogin",
-    "EmailLogin",
-    "PasswordLogin",
 ]
-

pixelarraythirdparty/unified_login/unified_login.py

@@ -48,11 +48,6 @@ class OAuth2Login(AsyncClient):
 
     # 提供商端点映射
     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",
@@ -61,23 +56,10 @@ class OAuth2Login(AsyncClient):
             "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",
         },
-        "tiktok": {
-            "auth_url": "/api/unified-login/tiktok/auth-url",
-            "wait_login": "/api/unified-login/tiktok/wait-login",
-        },
     }
 
     def __init__(
@@ -92,7 +74,7 @@ class OAuth2Login(AsyncClient):
             初始化OAuth2登录客户端
         parameters:
             api_key(str): API密钥
-            provider(str): 提供商名称，可选值：google, wechat, github, gitlab, douyin, tiktok
+            provider(str): 提供商名称，可选值：wechat, douyin
             login_type(str, optional): 登录类型，仅对微信有效，可选值：desktop（PC端扫码）, mobile（手机端）
             project_name(str, optional): 绑定项目名；不传或空字符串则匿名登录
         """
@@ -187,144 +169,6 @@ class OAuth2Login(AsyncClient):
 
         return {"message": "登录超时或未完成授权"}, False
 
-    async def refresh_access_token(self, refresh_token: str) -> Tuple[Dict, bool]:
-        """
-        description:
-            使用refresh_token刷新access_token（仅支持Google和GitLab）
-
-            注意：GitLab 采用 token rotation（令牌轮换）机制，每次刷新时会返回新的 refresh_token，
-            旧的 refresh_token 会立即失效。必须保存新的 refresh_token 并替换旧的。
-            Google 也可能在某些情况下返回新的 refresh_token。
-        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 {"message": "该登录方式不支持 refresh_token"}, False
-
-        data, success = await self._request(
-            "POST",
-            endpoint,
-            json={"refresh_token": refresh_token},
-        )
-        if not success:
-            return data, False
-        return data, True
-
-
-class GoogleLogin(AsyncClient):
-    """
-    Google OAuth2 登录客户端
-
-    使用示例:
-    ```
-    # 服务端使用场景（推荐）
-    google = GoogleLogin(api_key="your_api_key")
-    # 1. 获取授权URL
-    auth_data, success = await google.get_auth_url()
-    if success:
-        auth_url = auth_data.get("auth_url")
-        state = auth_data.get("state")
-        # 将auth_url返回给前端，让用户点击授权
-        # 2. 等待登录结果（在服务端轮询）
-        user_info, success = await google.wait_for_login(state, timeout=180)
-        if success:
-            access_token = user_info.get("access_token")
-            refresh_token = user_info.get("refresh_token")
-    ```
-    """
-
-    def __init__(self, api_key: str):
-        super().__init__(api_key)
-
-    async def get_auth_url(
-        self, project_name: Optional[str] = None
-    ) -> Tuple[Optional[Dict[str, str]], bool]:
-        """
-        description:
-            获取Google OAuth授权URL（公共方法，供服务端调用）
-
-            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
-            获取到state后，使用wait_for_login方法等待登录结果。
-        parameters:
-            project_name(str, optional): 绑定项目名；不传或空字符串则匿名登录
-        return:
-            auth_data(dict, optional): 授权数据字典，包含auth_url和state
-            success(bool): 是否成功
-        """
-        payload = _auth_url_json(project_name)
-        if payload:
-            data, success = await self._request(
-                "POST", "/api/unified-login/google/auth-url", json=payload
-            )
-        else:
-            data, success = await self._request(
-                "POST", "/api/unified-login/google/auth-url"
-            )
-        if not success:
-            return data, False
-        auth_url = data.get("auth_url")
-        if not auth_url:
-            return None, False
-        return data, True
-
-    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
-        """
-        description:
-            等待Google登录结果，轮询检查登录状态（公共方法，供服务端调用）
-
-            服务端在用户点击授权后，调用此方法轮询等待登录结果。
-            此方法会持续轮询直到登录成功或超时。
-        parameters:
-            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
-            timeout(int, optional): 超时时间（秒），默认为180
-        return:
-            user_info(dict): 用户信息字典
-            success(bool): 是否成功
-        """
-        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/google/wait-login",
-                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 {"message": "登录超时或未完成授权"}, 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 data, False
-        return data, True
-
 
 class WechatLogin(AsyncClient):
     """
@@ -442,95 +286,6 @@ class WechatLogin(AsyncClient):
         return {"message": "登录超时或未完成授权"}, False
 
 
-class GitHubLogin(AsyncClient):
-    """
-    GitHub OAuth2 登录客户端
-
-    使用示例:
-    ```
-    # 服务端使用场景（推荐）
-    github = GitHubLogin(api_key="your_api_key")
-    # 1. 获取授权URL
-    auth_data, success = await github.get_auth_url()
-    if success:
-        auth_url = auth_data.get("auth_url")
-        state = auth_data.get("state")
-        # 将auth_url返回给前端，让用户点击授权
-        # 2. 等待登录结果（在服务端轮询）
-        user_info, success = await github.wait_for_login(state, timeout=180)
-        print(user_info, success)
-    ```
-    """
-
-    def __init__(self, api_key: str):
-        super().__init__(api_key)
-
-    async def get_auth_url(
-        self, project_name: Optional[str] = None
-    ) -> Tuple[Optional[Dict[str, str]], bool]:
-        """
-        description:
-            获取GitHub OAuth授权URL（公共方法，供服务端调用）
-
-            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
-            获取到state后，使用wait_for_login方法等待登录结果。
-        parameters:
-            project_name(str, optional): 绑定项目名；不传或空字符串则匿名登录
-        return:
-            auth_data(dict, optional): 授权数据字典，包含auth_url和state
-            success(bool): 是否成功
-        """
-        payload = _auth_url_json(project_name)
-        if payload:
-            data, success = await self._request(
-                "POST", "/api/unified-login/github/auth-url", json=payload
-            )
-        else:
-            data, success = await self._request(
-                "POST", "/api/unified-login/github/auth-url"
-            )
-        if not success:
-            return data, False
-        auth_url = data.get("auth_url")
-        if not auth_url:
-            return None, False
-        return data, True
-
-    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
-        """
-        description:
-            等待GitHub登录结果，轮询检查登录状态（公共方法，供服务端调用）
-
-            服务端在用户点击授权后，调用此方法轮询等待登录结果。
-            此方法会持续轮询直到登录成功或超时。
-        parameters:
-            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
-            timeout(int, optional): 超时时间（秒），默认为180
-        return:
-            user_info(dict): 用户信息字典
-            success(bool): 是否成功
-        """
-        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/github/wait-login",
-                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 {"message": "登录超时或未完成授权"}, False
-
-
 class DouyinLogin(AsyncClient):
     """
     抖音 OAuth2 登录客户端
@@ -620,531 +375,3 @@ class DouyinLogin(AsyncClient):
         return {"message": "登录超时或未完成授权"}, False
 
 
-class TiktokLogin(AsyncClient):
-    """
-    TikTok OAuth2 登录客户端
-
-    使用示例:
-    ```
-    # 服务端使用场景（推荐）
-    tiktok = TiktokLogin(api_key="your_api_key")
-    # 1. 获取授权URL
-    auth_data, success = await tiktok.get_auth_url()
-    if success:
-        auth_url = auth_data.get("auth_url")
-        state = auth_data.get("state")
-        # 将auth_url返回给前端，让用户点击授权
-        # 2. 等待登录结果（在服务端轮询）
-        user_info, success = await tiktok.wait_for_login(state, timeout=180)
-        print(user_info, success)
-    ```
-    """
-
-    def __init__(self, api_key: str):
-        super().__init__(api_key)
-
-    async def get_auth_url(
-        self, project_name: Optional[str] = None
-    ) -> Tuple[Optional[Dict[str, str]], bool]:
-        """
-        description:
-            获取TikTok OAuth授权URL（公共方法，供服务端调用）
-
-            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
-            获取到state后，使用wait_for_login方法等待登录结果。
-        parameters:
-            project_name(str, optional): 绑定项目名；不传或空字符串则匿名登录
-        return:
-            auth_data(dict, optional): 授权数据字典，包含auth_url和state
-            success(bool): 是否成功
-        """
-        payload = _auth_url_json(project_name)
-        if payload:
-            data, success = await self._request(
-                "POST", "/api/unified-login/tiktok/auth-url", json=payload
-            )
-        else:
-            data, success = await self._request(
-                "POST", "/api/unified-login/tiktok/auth-url"
-            )
-        if not success:
-            return data, False
-        auth_url = data.get("auth_url")
-        if not auth_url:
-            return None, False
-        return data, True
-
-    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
-        """
-        description:
-            等待TikTok登录结果，轮询检查登录状态（公共方法，供服务端调用）
-
-            服务端在用户点击授权后，调用此方法轮询等待登录结果。
-            此方法会持续轮询直到登录成功或超时。
-        parameters:
-            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
-            timeout(int, optional): 超时时间（秒），默认为180
-        return:
-            user_info(dict): 用户信息字典
-            success(bool): 是否成功
-        """
-        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/tiktok/wait-login",
-                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 {"message": "登录超时或未完成授权"}, False
-
-
-class GitLabLogin(AsyncClient):
-    """
-    GitLab OAuth2 登录客户端
-
-    使用示例:
-    ```
-    # 服务端使用场景（推荐）
-    gitlab = GitLabLogin(api_key="your_api_key")
-    # 1. 获取授权URL
-    auth_data, success = await gitlab.get_auth_url()
-    if success:
-        auth_url = auth_data.get("auth_url")
-        state = auth_data.get("state")
-        # 将auth_url返回给前端，让用户点击授权
-        # 2. 等待登录结果（在服务端轮询）
-        user_info, success = await gitlab.wait_for_login(state, timeout=180)
-        print(user_info, success)
-    ```
-    """
-
-    def __init__(self, api_key: str):
-        super().__init__(api_key)
-
-    async def get_auth_url(
-        self, project_name: Optional[str] = None
-    ) -> Tuple[Optional[Dict[str, str]], bool]:
-        """
-        description:
-            获取GitLab OAuth授权URL（公共方法，供服务端调用）
-
-            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
-            获取到state后，使用wait_for_login方法等待登录结果。
-        parameters:
-            project_name(str, optional): 绑定项目名；不传或空字符串则匿名登录
-        return:
-            auth_data(dict, optional): 授权数据字典，包含auth_url和state
-            success(bool): 是否成功
-        """
-        payload = _auth_url_json(project_name)
-        if payload:
-            data, success = await self._request(
-                "POST", "/api/unified-login/gitlab/auth-url", json=payload
-            )
-        else:
-            data, success = await self._request(
-                "POST", "/api/unified-login/gitlab/auth-url"
-            )
-        if not success:
-            return data, False
-        auth_url = data.get("auth_url")
-        if not auth_url:
-            return None, False
-        return data, True
-
-    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
-        """
-        description:
-            等待GitLab登录结果，轮询检查登录状态（公共方法，供服务端调用）
-
-            服务端在用户点击授权后，调用此方法轮询等待登录结果。
-            此方法会持续轮询直到登录成功或超时。
-        parameters:
-            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
-            timeout(int, optional): 超时时间（秒），默认为180
-        return:
-            user_info(dict): 用户信息字典
-            success(bool): 是否成功
-        """
-        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/gitlab/wait-login",
-                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 {"message": "登录超时或未完成授权"}, False
-
-    async def refresh_access_token(self, refresh_token: str) -> Tuple[Dict, bool]:
-        """
-        description:
-            使用refresh_token刷新access_token
-
-            注意：GitLab 采用 token rotation（令牌轮换）机制，每次刷新时会返回新的 refresh_token，
-            旧的 refresh_token 会立即失效。必须保存新的 refresh_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 data, False
-        return data, True
-
-
-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, project_name: Optional[str] = None
-    ) -> bool:
-        """
-        验证短信验证码
-
-        :param phone: 手机号码
-        :param code: 验证码
-        :param project_name: 绑定项目名；不传或空字符串则匿名登录
-        :return: success 是否成功
-        """
-        payload: Dict[str, Any] = {"phone": phone, "code": code}
-        pn = _normalized_project_name(project_name)
-        if pn is not None:
-            payload["project_name"] = pn
-        _, success = await self._request(
-            "POST",
-            "/api/unified-login/sms/verify-code",
-            json=payload,
-        )
-        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 {"message": "登录超时或未完成授权"}, False
-
-    async def login(
-        self,
-        phone: str,
-        code: str,
-        timeout: int = 180,
-        project_name: Optional[str] = None,
-    ) -> Tuple[Dict, bool]:
-        """
-        验证验证码并等待登录结果
-
-        :param phone: 手机号码
-        :param code: 验证码
-        :param timeout: 等待登录结果的超时时间（秒）
-        :param project_name: 绑定项目名；不传或空字符串则匿名登录
-        :return: (用户信息, 是否成功)
-        """
-        success = await self.verify_code(phone, code, project_name=project_name)
-        if not success:
-            return {"message": "验证码校验失败"}, 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, project_name: Optional[str] = None
-    ) -> bool:
-        """
-        验证邮箱验证码
-
-        :param email: 邮箱地址
-        :param code: 验证码
-        :param project_name: 绑定项目名；不传或空字符串则匿名登录
-        :return: success 是否成功
-        """
-        payload: Dict[str, Any] = {"email": email, "code": code}
-        pn = _normalized_project_name(project_name)
-        if pn is not None:
-            payload["project_name"] = pn
-        _, success = await self._request(
-            "POST",
-            "/api/unified-login/email/verify-code",
-            json=payload,
-        )
-        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 {"message": "登录超时或未完成授权"}, False
-
-    async def login(
-        self,
-        email: str,
-        code: str,
-        timeout: int = 180,
-        project_name: Optional[str] = None,
-    ) -> Tuple[Dict, bool]:
-        """
-        验证验证码并等待登录结果
-
-        :param email: 邮箱地址
-        :param code: 验证码
-        :param timeout: 等待登录结果的超时时间（秒）
-        :param project_name: 绑定项目名；不传或空字符串则匿名登录
-        :return: (用户信息, 是否成功)
-        """
-        success = await self.verify_code(email, code, project_name=project_name)
-        if not success:
-            return {"message": "验证码校验失败"}, False
-
-        return await self._wait_for_login(email, timeout)
-
-
-class PasswordLogin(AsyncClient):
-    """
-    密码登录客户端（邮箱 + 密码，统一登录外部用户表）
-
-    使用示例:
-    ```
-    password_client = PasswordLogin(api_key="your_api_key")
-    # 注册/设置密码
-    success = await password_client.register(
-        user_identifier="user@example.com",
-        password="your_password",
-        display_name="可选展示名",
-    )
-    if success:
-        # 登录
-        user_info, success = await password_client.login(
-            user_identifier="user@example.com",
-            password="your_password",
-        )
-    # 修改密码
-    success = await password_client.change_password(
-        user_identifier="user@example.com",
-        old_password="old_password",
-        new_password="new_password",
-    )
-    ```
-    """
-
-    def __init__(self, api_key: str):
-        super().__init__(api_key)
-
-    async def register(
-        self,
-        user_identifier: str,
-        password: str,
-        display_name: Optional[str] = None,
-        project_name: Optional[str] = None,
-    ) -> bool:
-        """
-        注册/设置密码：将密码哈希后写入外部用户表（login_method=password）。
-        若该邮箱已存在则更新密码与展示名称。
-
-        :param user_identifier: 用户标识（邮箱）
-        :param password: 密码（6～100 位）
-        :param display_name: 展示名称，可选
-        :param project_name: 绑定项目名；不传或空字符串则匿名登录
-        :return: 是否成功
-        """
-        payload: Dict[str, Any] = {
-            "user_identifier": user_identifier,
-            "password": password,
-        }
-        if display_name is not None:
-            payload["display_name"] = display_name
-        pn = _normalized_project_name(project_name)
-        if pn is not None:
-            payload["project_name"] = pn
-        _, success = await self._request(
-            "POST",
-            "/api/unified-login/password/register",
-            json=payload,
-        )
-        return bool(success)
-
-    async def login(
-        self,
-        user_identifier: str,
-        password: str,
-        project_name: Optional[str] = None,
-    ) -> Tuple[Dict, bool]:
-        """
-        密码登录：校验邮箱与密码，成功则返回用户信息（与其它统一登录方式格式一致）。
-
-        :param user_identifier: 用户标识（邮箱）
-        :param password: 密码
-        :param project_name: 绑定项目名；不传或空字符串则匿名登录
-        :return: (用户信息字典, 是否成功)
-        """
-        body: Dict[str, Any] = {
-            "user_identifier": user_identifier,
-            "password": password,
-        }
-        pn = _normalized_project_name(project_name)
-        if pn is not None:
-            body["project_name"] = pn
-        data, success = await self._request(
-            "POST",
-            "/api/unified-login/password/login",
-            json=body,
-        )
-        if not success:
-            return data if isinstance(data, dict) else {"message": data}, False
-        return data, True
-
-    async def change_password(
-        self,
-        user_identifier: str,
-        old_password: str,
-        new_password: str,
-        project_name: Optional[str] = None,
-    ) -> bool:
-        """
-        修改密码：校验原密码后更新为新密码。
-
-        :param user_identifier: 用户标识（邮箱）
-        :param old_password: 当前密码
-        :param new_password: 新密码（6～100 位）
-        :param project_name: 绑定项目名；不传或空字符串则匿名登录
-        :return: 是否成功
-        """
-        body: Dict[str, Any] = {
-            "user_identifier": user_identifier,
-            "old_password": old_password,
-            "new_password": new_password,
-        }
-        pn = _normalized_project_name(project_name)
-        if pn is not None:
-            body["project_name"] = pn
-        _, success = await self._request(
-            "POST",
-            "/api/unified-login/password/change",
-            json=body,
-        )
-        return bool(success)

{pixelarraythirdparty-1.3.7.dist-info → pixelarraythirdparty-1.3.9.dist-info}/METADATA

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

{pixelarraythirdparty-1.3.7.dist-info → pixelarraythirdparty-1.3.9.dist-info}/RECORD

@@ -1,13 +1,9 @@
-pixelarraythirdparty/__init__.py,sha256=sqCqzAKk3COl1injSXS2ZAENGLFhlWkOW5SEx5KDsS8,1317
-pixelarraythirdparty/client.py,sha256=hICdd1MSBrxtoo4BgXSdmKchLehbpJcQ486SO9_fmuI,4459
-pixelarraythirdparty/cron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pixelarraythirdparty/cron/cron.py,sha256=Cm5J1XppXh1raqtlWwpkdcsztWpQZIGY7FOt1VH9Pz0,3152
-pixelarraythirdparty/custom_events/__init__.py,sha256=dwB0mRElWp--5KmDVT7ZhGZ5xZdrO_ZKybngfAHm0zw,92
-pixelarraythirdparty/custom_events/custom_events.py,sha256=_5TvbzW0istvX9HGsCWVCSoCy5eHlMHWlab_01i9XzE,8468
+pixelarraythirdparty/__init__.py,sha256=BWY-vq7lCNKdEbkiAoeCCqTsBYw9_cAF5yFlczz5jfc,1078
+pixelarraythirdparty/client.py,sha256=tzlH-aJ0ZeeoHStvF2omDRFv0Kl-why1FLr3fb_J0pM,4459
 pixelarraythirdparty/feedback/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixelarraythirdparty/feedback/feedback.py,sha256=bwR2qeors_G2zFoKkefsJrPrLzCxndoXGru-aVsiRSI,11596
 pixelarraythirdparty/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pixelarraythirdparty/order/order.py,sha256=ghpnzEbrQLcyDhRBFeBKodZeqhxQhIBQsuAzFM_XCdg,15952
+pixelarraythirdparty/order/order.py,sha256=5bAHV5bvTCnurHgj7SnusRK7rBgjO9DCgBPrWo8MtdE,17841
 pixelarraythirdparty/product/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixelarraythirdparty/product/product.py,sha256=fELowDk073SAmNJ2iW14UjyePH5g1X5YDJMTkVysA3E,7509
 pixelarraythirdparty/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -16,12 +12,12 @@ pixelarraythirdparty/project_dashboard/__init__.py,sha256=yeVhw4smnQ8-xN-BG3aZ7s
 pixelarraythirdparty/project_dashboard/project_dashboard.py,sha256=vOL6mTU69c8rrotaodrf0pU8GGYDLBk23USyQw_TC50,2747
 pixelarraythirdparty/support_chat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixelarraythirdparty/support_chat/support_chat.py,sha256=AF82p_vaN5Oefywf0H7wqnOAPPDKw2X2W2St2gKdZ7I,5594
-pixelarraythirdparty/unified_login/__init__.py,sha256=bWG_I7GMHilWZvnxjVJFmHgxioRdFFvpi95XJunl_fY,403
-pixelarraythirdparty/unified_login/unified_login.py,sha256=15fNyhm6HKgjPMO1RCqpxzlAzBAJuGZbRMr4gABh4MA,40575
+pixelarraythirdparty/unified_login/__init__.py,sha256=OUJkqR1uH7pR_733s-tVwUhvpQKnbPvSqHSLg4xD6xM,154
+pixelarraythirdparty/unified_login/unified_login.py,sha256=46ZJruQSIxO6KVKyF4aW1i4trBtE5mEXWOhHGxjMmQ8,13865
 pixelarraythirdparty/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pixelarraythirdparty/user/user.py,sha256=G-dldmbuUQN1JPicuC2G4qvIY4Mq7pZIPh3lOyWpSqo,5773
-pixelarraythirdparty-1.3.7.dist-info/licenses/LICENSE,sha256=O-g1dUr0U50rSIvmWE9toiVkSgFpVt72_MHITbWvAqA,1067
-pixelarraythirdparty-1.3.7.dist-info/METADATA,sha256=0vWr-FQSTMLHpopS0gKif1v54y8sqpEZtnCAeejQ6_M,1044
-pixelarraythirdparty-1.3.7.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pixelarraythirdparty-1.3.7.dist-info/top_level.txt,sha256=dzG2Ut8j7noUqj_0ZQjcIDAeHYCh_9WtlxjAxtoyufo,21
-pixelarraythirdparty-1.3.7.dist-info/RECORD,,
+pixelarraythirdparty-1.3.9.dist-info/licenses/LICENSE,sha256=O-g1dUr0U50rSIvmWE9toiVkSgFpVt72_MHITbWvAqA,1067
+pixelarraythirdparty-1.3.9.dist-info/METADATA,sha256=sstKgVVJ9xHxQRrcH8N4PjhrRMlHvYejJn8HXxgXCGE,1044
+pixelarraythirdparty-1.3.9.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pixelarraythirdparty-1.3.9.dist-info/top_level.txt,sha256=dzG2Ut8j7noUqj_0ZQjcIDAeHYCh_9WtlxjAxtoyufo,21
+pixelarraythirdparty-1.3.9.dist-info/RECORD,,

{pixelarraythirdparty-1.3.7.dist-info → pixelarraythirdparty-1.3.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pixelarraythirdparty/cron/cron.py

@@ -1,80 +0,0 @@
-from pixelarraythirdparty.client import AsyncClient
-
-
-class CronManagerAsync(AsyncClient):
-    async def list_cron_task(self):
-        """
-        description:
-            获取所有配置的定时任务列表，包括任务详情、执行时间、状态等。
-        return:
-            data(dict): 定时任务列表信息
-                - tasks(list): 定时任务列表
-                    - id(str): 任务ID
-                    - name(str): 任务名称
-                    - description(str): 任务描述
-                    - schedule(str): 执行时间
-                    - enabled(bool): 是否启用
-                    - task_name(str): 任务函数名
-                    - module_name(str): 模块名
-                    - function_name(str): 函数名
-                    - file_path(str): 文件路径
-                    - parameters(list): 参数列表
-                    - task_config(dict): 任务配置
-                    - registration_info(dict): 注册信息
-                - count(int): 任务数量
-                - timestamp(str): 获取时间
-            success(bool): 操作是否成功
-        """
-        data, success = await self._request("GET", "/api/cron/tasks/scheduled")
-        if not success:
-            return data, False
-        return data, True
-
-    async def get_cron_tasks_detail(self, task_name: str):
-        """
-        description:
-            根据任务名称获取指定任务的详细信息。
-        parameters:
-            task_name(str): 任务名称
-        return:
-            data(dict): 任务详细信息
-                - task_name(str): 任务名称
-                - module_name(str): 模块名
-                - function_name(str): 函数名
-                - file_path(str): 文件路径
-                - description(str): 任务描述
-                - parameters(list): 参数列表
-                - task_config(dict): 任务配置
-                - registration_info(dict): 注册信息
-                - timestamp(str): 获取时间
-            success(bool): 操作是否成功
-        """
-        data, success = await self._request("GET", f"/api/cron/tasks/{task_name}")
-        if not success:
-            return data, False
-        return data, True
-
-    async def trigger_cron_task(self, task_name: str, args: list, kwargs: dict):
-        """
-        description:
-            手动触发指定任务的执行，支持传递参数。
-        parameters:
-            task_name(str): 任务名称
-            args(list): 任务参数列表
-            kwargs(dict): 任务关键字参数
-        return:
-            data(dict): 任务触发信息
-                - task_id(str): 任务ID
-                - task_name(str): 任务名称
-                - status(str): 任务状态，初始为"PENDING"
-                - message(str): 触发消息
-            success(bool): 操作是否成功
-        """
-        data, success = await self._request(
-            "POST",
-            f"/api/cron/tasks/{task_name}/trigger",
-            json={"args": args, "kwargs": kwargs},
-        )
-        if not success:
-            return data, False
-        return data, True

pixelarraythirdparty/custom_events/__init__.py

@@ -1,3 +0,0 @@
-from .custom_events import CustomEventsManagerAsync
-
-__all__ = ["CustomEventsManagerAsync"]

pixelarraythirdparty/custom_events/custom_events.py

@@ -1,220 +0,0 @@
-from pixelarraythirdparty.client import AsyncClient
-from typing import Any, Dict, List, Optional, Tuple
-
-
-class CustomEventsManagerAsync(AsyncClient):
-    """自定义事件：新建定义与上报（上报前须存在对应事件定义与字段 schema）。"""
-
-    def _dashboard_params(
-        self,
-        project_name: str,
-        *,
-        start_date: Optional[str] = None,
-        end_date: Optional[str] = None,
-        top_events_limit: Optional[int] = None,
-    ) -> Dict[str, Any]:
-        p: Dict[str, Any] = {"project_name": project_name}
-        if start_date is not None:
-            p["start_date"] = start_date
-        if end_date is not None:
-            p["end_date"] = end_date
-        if top_events_limit is not None:
-            p["top_events_limit"] = top_events_limit
-        return p
-
-    async def create_custom_event_definition(
-        self,
-        project_name: str,
-        event_key: str,
-        display_name: str,
-        *,
-        description: Optional[str] = None,
-        category: str = "custom",
-        field_schema: Optional[List[Dict[str, Any]]] = None,
-        is_active: bool = True,
-    ) -> Tuple[Dict[str, Any], bool]:
-        """
-        description:
-            新建自定义事件定义（需 API Key；与 Portal「新建定义」一致，对应 POST /api/custom-events/definitions/create）
-        parameters:
-            project_name(str): 项目名称（与 projects.name 一致）
-            event_key(str): 事件键（1~64 字符）
-            display_name(str): 展示名
-            description(str, optional): 说明
-            category(str): 分类白名单，默认 custom
-            field_schema(list, optional): 字段定义列表，每项含 name、type(string|number|boolean)、required、description
-            is_active(bool): 是否启用，默认 True
-        return:
-            data(dict): 成功时为定义记录；失败时含 message 等
-            success(bool): 是否成功
-        """
-        body: Dict[str, Any] = {
-            "project_name": project_name,
-            "event_key": event_key,
-            "display_name": display_name,
-            "category": category,
-            "field_schema": field_schema or [],
-            "is_active": is_active,
-        }
-        if description is not None:
-            body["description"] = description
-        return await self._request(
-            "POST", "/api/custom-events/definitions/create", json=body
-        )
-
-    async def get_custom_event_common_field_schema(
-        self, project_name: str
-    ) -> Tuple[Dict[str, Any], bool]:
-        """
-        description:
-            查询项目自定义事件公共维度（GET /api/custom-events/common-field-schema）
-        """
-        return await self._request(
-            "GET",
-            "/api/custom-events/common-field-schema",
-            params={"project_name": project_name},
-        )
-
-    async def update_custom_event_common_field_schema(
-        self,
-        project_name: str,
-        field_schema: List[Dict[str, Any]],
-    ) -> Tuple[Dict[str, Any], bool]:
-        """
-        description:
-            更新项目公共维度；传空列表表示恢复服务端内置默认（POST /api/custom-events/common-field-schema/update）
-        parameters:
-            field_schema: 每项含 name、type、required、可选 nullable、description
-        """
-        body: Dict[str, Any] = {
-            "project_name": project_name,
-            "field_schema": field_schema or [],
-        }
-        return await self._request(
-            "POST", "/api/custom-events/common-field-schema/update", json=body
-        )
-
-    async def report_custom_event(
-        self,
-        project_name: str,
-        event_key: str,
-        payload: Dict[str, Any],
-        client_occurred_at: Optional[str] = None,
-    ) -> Tuple[Dict[str, Any], bool]:
-        """
-        description:
-            上报单条自定义事件日志（有效载荷 = 项目公共维度 ∪ 该事件 field_schema；未传的公共键由服务端补 null）
-        parameters:
-            project_name(str): 项目名称（与 projects.name 一致）
-            event_key(str): 事件键
-            payload(dict): JSON 对象，键与类型须与定义一致
-            client_occurred_at(str, optional): 客户端事件发生时间，ISO8601 字符串
-        return:
-            data(dict): 成功时为日志记录；失败时含 message 等
-            success(bool): 是否成功
-        """
-        data: Dict[str, Any] = {
-            "project_name": project_name,
-            "event_key": event_key,
-            "payload": payload,
-        }
-        if client_occurred_at is not None:
-            data["client_occurred_at"] = client_occurred_at
-        return await self._request("POST", "/api/custom-events/report", json=data)
-
-    async def report_custom_events_batch(
-        self,
-        project_name: str,
-        items: List[Dict[str, Any]],
-    ) -> Tuple[Dict[str, Any], bool]:
-        """
-        description:
-            批量上报自定义事件（同一 project_name；任一条校验失败则整批失败）
-        parameters:
-            project_name(str): 项目名称（与 projects.name 一致）
-            items(list): 每项为 dict，须含 event_key、payload；可选 client_occurred_at（字符串）
-        return:
-            data(dict): 成功时为日志列表；失败时含 message
-            success(bool): 是否成功
-        """
-        body = {"project_name": project_name, "items": items}
-        return await self._request("POST", "/api/custom-events/report/batch", json=body)
-
-    async def get_custom_events_dashboard_summary(
-        self,
-        project_name: str,
-        *,
-        start_date: Optional[str] = None,
-        end_date: Optional[str] = None,
-    ) -> Tuple[Dict[str, Any], bool]:
-        """GET /api/custom-events/dashboard/summary：KPI 摘要（需 API Key 或 JWT）。"""
-        params = self._dashboard_params(
-            project_name, start_date=start_date, end_date=end_date
-        )
-        return await self._request(
-            "GET", "/api/custom-events/dashboard/summary", params=params
-        )
-
-    async def get_custom_events_dashboard_daily(
-        self,
-        project_name: str,
-        *,
-        start_date: Optional[str] = None,
-        end_date: Optional[str] = None,
-    ) -> Tuple[Dict[str, Any], bool]:
-        """GET /api/custom-events/dashboard/daily：按日事件量（UTC）。"""
-        params = self._dashboard_params(
-            project_name, start_date=start_date, end_date=end_date
-        )
-        return await self._request(
-            "GET", "/api/custom-events/dashboard/daily", params=params
-        )
-
-    async def get_custom_events_dashboard_top_events(
-        self,
-        project_name: str,
-        *,
-        start_date: Optional[str] = None,
-        end_date: Optional[str] = None,
-        top_events_limit: Optional[int] = None,
-    ) -> Tuple[Dict[str, Any], bool]:
-        """GET /api/custom-events/dashboard/top-events：事件量 TOP N。"""
-        params = self._dashboard_params(
-            project_name,
-            start_date=start_date,
-            end_date=end_date,
-            top_events_limit=top_events_limit,
-        )
-        return await self._request(
-            "GET", "/api/custom-events/dashboard/top-events", params=params
-        )
-
-    async def get_custom_events_dashboard_by_category(
-        self,
-        project_name: str,
-        *,
-        start_date: Optional[str] = None,
-        end_date: Optional[str] = None,
-    ) -> Tuple[Dict[str, Any], bool]:
-        """GET /api/custom-events/dashboard/by-category：按分类分布。"""
-        params = self._dashboard_params(
-            project_name, start_date=start_date, end_date=end_date
-        )
-        return await self._request(
-            "GET", "/api/custom-events/dashboard/by-category", params=params
-        )
-
-    async def get_custom_events_dashboard_by_hour(
-        self,
-        project_name: str,
-        *,
-        start_date: Optional[str] = None,
-        end_date: Optional[str] = None,
-    ) -> Tuple[Dict[str, Any], bool]:
-        """GET /api/custom-events/dashboard/by-hour：按 UTC 小时分布。"""
-        params = self._dashboard_params(
-            project_name, start_date=start_date, end_date=end_date
-        )
-        return await self._request(
-            "GET", "/api/custom-events/dashboard/by-hour", params=params
-        )