pixelarraythirdparty 1.2.3__tar.gz → 1.2.5__tar.gz

{pixelarraythirdparty-1.2.3 → pixelarraythirdparty-1.2.5}/PKG-INFO

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

{pixelarraythirdparty-1.2.3 → pixelarraythirdparty-1.2.5}/pixelarraythirdparty/__init__.py

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

{pixelarraythirdparty-1.2.3 → pixelarraythirdparty-1.2.5}/pixelarraythirdparty/unified_login/__init__.py

@@ -4,6 +4,7 @@ from .unified_login import (
     WechatLogin,
     GitHubLogin,
     DouyinLogin,
+    TiktokLogin,
     GitLabLogin,
     SMSLogin,
     EmailLogin,
@@ -15,6 +16,7 @@ __all__ = [
     "WechatLogin",
     "GitHubLogin",
     "DouyinLogin",
+    "TiktokLogin",
     "GitLabLogin",
     "SMSLogin",
     "EmailLogin",

{pixelarraythirdparty-1.2.3 → pixelarraythirdparty-1.2.5}/pixelarraythirdparty/unified_login/unified_login.py

@@ -9,57 +9,29 @@ from pixelarraythirdparty.client import AsyncClient
 class OAuth2Login(AsyncClient):
     """
     统一的 OAuth2 登录客户端基类
-    
-    支持所有基于 OAuth2 的第三方登录（Google、微信、GitHub、GitLab、抖音等）
+
+    支持所有基于 OAuth2 的第三方登录（Google、微信、GitHub、GitLab、抖音、TikTok等）
     通过配置不同的端点来支持不同的提供商
-    
+
     使用示例:
     ```
     # 服务端使用场景（推荐）
-    google = OAuth2Login(
+    oauth2_login = OAuth2Login(
         api_key="your_api_key",
-        provider="google"
+        provider="google" # 支持的提供商：google, wechat, github, gitlab, douyin
     )
     # 1. 获取授权URL
-    auth_data, success = await google.get_auth_url()
+    auth_data, success = await oauth2_login.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)
-    
-    # 测试场景（仅用于本地测试，会打开浏览器）
-    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")
-        )
+        user_info, success = await oauth2_login.wait_for_login(state, timeout=180)
+        print(user_info, success)
     ```
     """
-    
+
     # 提供商端点映射
     PROVIDER_ENDPOINTS = {
         "google": {
@@ -88,38 +60,37 @@ class OAuth2Login(AsyncClient):
             "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__(
-        self,
-        api_key: str,
-        provider: str,
-        login_type: Optional[str] = None
-    ):
+
+    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
+            provider(str): 提供商名称，可选值：google, wechat, github, gitlab, douyin, tiktok
             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:
@@ -132,16 +103,14 @@ class OAuth2Login(AsyncClient):
         endpoints = self.PROVIDER_ENDPOINTS.get(self.provider, {})
         endpoint = endpoints.get(endpoint_type)
         if not endpoint:
-            raise ValueError(
-                f"提供商 {self.provider} 不支持 {endpoint_type} 端点"
-            )
+            raise ValueError(f"提供商 {self.provider} 不支持 {endpoint_type} 端点")
         return endpoint
-    
+
     async def get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
         """
         description:
             获取OAuth授权URL（公共方法，供服务端调用）
-            
+
             服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
             获取到state后，使用wait_for_login方法等待登录结果。
         return:
@@ -156,35 +125,12 @@ class OAuth2Login(AsyncClient):
         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 = 180
-    ) -> Tuple[Dict, bool]:
+
+    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
         """
         description:
             等待登录结果，轮询检查登录状态（公共方法，供服务端调用）
-            
+
             服务端在用户点击授权后，调用此方法轮询等待登录结果。
             此方法会持续轮询直到登录成功或超时。
         parameters:
@@ -197,56 +143,29 @@ class OAuth2Login(AsyncClient):
         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 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
-            
-            注意：此方法仅用于本地测试场景，会自动打开浏览器。
-            在生产环境的服务端场景中，应该使用get_auth_url和wait_for_login方法。
-        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）
-            
+
             注意：GitLab 采用 token rotation（令牌轮换）机制，每次刷新时会返回新的 refresh_token，
             旧的 refresh_token 会立即失效。必须保存新的 refresh_token 并替换旧的。
             Google 也可能在某些情况下返回新的 refresh_token。
@@ -260,7 +179,7 @@ class OAuth2Login(AsyncClient):
             endpoint = self._get_endpoint("refresh_token")
         except ValueError:
             return {}, False
-        
+
         data, success = await self._request(
             "POST",
             endpoint,
@@ -290,16 +209,6 @@ class GoogleLogin(AsyncClient):
         if success:
             access_token = user_info.get("access_token")
             refresh_token = user_info.get("refresh_token")
-            
-            # 使用refresh_token刷新access_token
-            if refresh_token:
-                token_data, success = await google.refresh_access_token(refresh_token)
-                if success:
-                    new_access_token = token_data.get("access_token")
-    
-    # 测试场景（仅用于本地测试，会打开浏览器）
-    google = GoogleLogin(api_key="your_api_key")
-    user_info, success = await google.login()
     ```
     """
 
@@ -310,7 +219,7 @@ class GoogleLogin(AsyncClient):
         """
         description:
             获取Google OAuth授权URL（公共方法，供服务端调用）
-            
+
             服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
             获取到state后，使用wait_for_login方法等待登录结果。
         return:
@@ -327,53 +236,11 @@ class GoogleLogin(AsyncClient):
             return None, False
         return data, True
 
-    async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
-        """
-        description:
-            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
-            
-            注意：此方法仅用于本地测试场景，会自动打开浏览器。
-            在生产环境的服务端场景中，应该使用get_auth_url和wait_for_login方法。
-        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)
-
-    def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
-        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 = 180
-    ) -> Tuple[Dict, bool]:
+    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
         """
         description:
             等待Google登录结果，轮询检查登录状态（公共方法，供服务端调用）
-            
+
             服务端在用户点击授权后，调用此方法轮询等待登录结果。
             此方法会持续轮询直到登录成功或超时。
         parameters:
@@ -426,7 +293,7 @@ class GoogleLogin(AsyncClient):
 class WechatLogin(AsyncClient):
     """
     微信 OAuth2 登录客户端
-    
+
     支持两种登录方式：
     - desktop: PC端扫码登录（使用微信开放平台）
     - mobile: 微信公众号OAuth登录（手机端微信内打开）
@@ -443,7 +310,8 @@ class WechatLogin(AsyncClient):
         # 将auth_url返回给前端，让用户扫码授权
         # 等待登录结果
         user_info, success = await wechat.wait_for_login(state, timeout=180, login_type="desktop")
-    
+        print(user_info, success)
+
     # 微信公众号登录（手机端）
     auth_data, success = await wechat.get_auth_url(login_type="mobile")
     if success:
@@ -452,21 +320,20 @@ class WechatLogin(AsyncClient):
         # 将auth_url返回给前端，让用户在微信内打开授权
         # 等待登录结果
         user_info, success = await wechat.wait_for_login(state, timeout=180, login_type="mobile")
-    
-    # 测试场景（仅用于本地测试，会打开浏览器）
-    wechat = WechatLogin(api_key="your_api_key")
-    user_info, success = await wechat.login(login_type="desktop")
+        print(user_info, success)
     ```
     """
 
     def __init__(self, api_key: str):
         super().__init__(api_key)
 
-    async def get_auth_url(self, login_type: str = "desktop") -> Tuple[Optional[Dict[str, str]], bool]:
+    async def get_auth_url(
+        self, login_type: str = "desktop"
+    ) -> Tuple[Optional[Dict[str, str]], bool]:
         """
         description:
             获取微信授权URL（公共方法，供服务端调用）
-            
+
             服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
             获取到state后，使用wait_for_login方法等待登录结果。
         parameters:
@@ -481,7 +348,7 @@ class WechatLogin(AsyncClient):
         else:
             # PC端扫码登录
             endpoint = "/api/unified-login/wechat/auth-url"
-        
+
         data, success = await self._request("POST", endpoint)
         if not success:
             return None, False
@@ -490,62 +357,13 @@ class WechatLogin(AsyncClient):
             return None, False
         return data, True
 
-    async def login(self, login_type: str = "desktop", timeout: int = 180) -> Tuple[Dict, bool]:
-        """
-        description:
-            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
-            
-            注意：此方法仅用于本地测试场景，会自动打开浏览器。
-            在生产环境的服务端场景中，应该使用get_auth_url和wait_for_login方法。
-        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:
-            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, 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:
-            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 = 180, login_type: str = "desktop"
     ) -> Tuple[Dict, bool]:
         """
         description:
             等待微信登录结果，轮询检查登录状态（公共方法，供服务端调用）
-            
+
             服务端在用户点击授权后，调用此方法轮询等待登录结果。
             此方法会持续轮询直到登录成功或超时。
         parameters:
@@ -599,10 +417,7 @@ class GitHubLogin(AsyncClient):
         # 将auth_url返回给前端，让用户点击授权
         # 2. 等待登录结果（在服务端轮询）
         user_info, success = await github.wait_for_login(state, timeout=180)
-    
-    # 测试场景（仅用于本地测试，会打开浏览器）
-    github = GitHubLogin(api_key="your_api_key")
-    user_info, success = await github.login()
+        print(user_info, success)
     ```
     """
 
@@ -613,7 +428,7 @@ class GitHubLogin(AsyncClient):
         """
         description:
             获取GitHub OAuth授权URL（公共方法，供服务端调用）
-            
+
             服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
             获取到state后，使用wait_for_login方法等待登录结果。
         return:
@@ -630,61 +445,11 @@ class GitHubLogin(AsyncClient):
             return None, False
         return data, True
 
-    async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
-        """
-        description:
-            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
-            
-            注意：此方法仅用于本地测试场景，会自动打开浏览器。
-            在生产环境的服务端场景中，应该使用get_auth_url和wait_for_login方法。
-        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)
-
-    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 = 180
-    ) -> Tuple[Dict, bool]:
+    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
         """
         description:
             等待GitHub登录结果，轮询检查登录状态（公共方法，供服务端调用）
-            
+
             服务端在用户点击授权后，调用此方法轮询等待登录结果。
             此方法会持续轮询直到登录成功或超时。
         parameters:
@@ -731,10 +496,7 @@ class DouyinLogin(AsyncClient):
         # 将auth_url返回给前端，让用户点击授权
         # 2. 等待登录结果（在服务端轮询）
         user_info, success = await douyin.wait_for_login(state, timeout=180)
-    
-    # 测试场景（仅用于本地测试，会打开浏览器）
-    douyin = DouyinLogin(api_key="your_api_key")
-    user_info, success = await douyin.login()
+        print(user_info, success)
     ```
     """
 
@@ -745,7 +507,7 @@ class DouyinLogin(AsyncClient):
         """
         description:
             获取抖音OAuth授权URL（公共方法，供服务端调用）
-            
+
             服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
             获取到state后，使用wait_for_login方法等待登录结果。
         return:
@@ -762,61 +524,90 @@ class DouyinLogin(AsyncClient):
             return None, False
         return data, True
 
-    async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
+    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
         """
         description:
-            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
-            
-            注意：此方法仅用于本地测试场景，会自动打开浏览器。
-            在生产环境的服务端场景中，应该使用get_auth_url和wait_for_login方法。
+            等待抖音登录结果，轮询检查登录状态（公共方法，供服务端调用）
+
+            服务端在用户点击授权后，调用此方法轮询等待登录结果。
+            此方法会持续轮询直到登录成功或超时。
         parameters:
-            timeout(int, optional): 等待用户完成授权的超时时间（秒），默认为180
+            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
+            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
+        interval = 2
+        total_checks = max(1, timeout // interval) if timeout > 0 else 1
 
-        auth_url = auth_data.get("auth_url")
-        state = auth_data.get("state") or self._extract_state(auth_url)
+        for _ in range(total_checks):
+            status, response = await self._request_raw(
+                "POST",
+                "/api/unified-login/douyin/wait-login",
+                json={"state": state},
+            )
 
-        if not auth_url or not state:
-            return {}, False
+            if status == 200 and response.get("success") is True:
+                return response.get("data", {}), True
 
-        webbrowser.open(auth_url, new=2)
+            if status in (400, 408):
+                break
+
+            await asyncio.sleep(interval)
+
+        return {}, 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)
+    ```
+    """
 
-        return await self.wait_for_login(state, timeout)
+    def __init__(self, api_key: str):
+        super().__init__(api_key)
 
-    def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
+    async def get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
         """
         description:
-            从授权URL中提取state参数
-        parameters:
-            auth_url(str, optional): 授权URL
+            获取TikTok OAuth授权URL（公共方法，供服务端调用）
+
+            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
+            获取到state后，使用wait_for_login方法等待登录结果。
         return:
-            state(str, optional): state参数值，如果提取失败则返回None
+            auth_data(dict, optional): 授权数据字典，包含auth_url和state
+            success(bool): 是否成功
         """
+        data, success = await self._request(
+            "POST", "/api/unified-login/tiktok/auth-url"
+        )
+        if not success:
+            return None, False
+        auth_url = data.get("auth_url")
         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
+            return None, False
+        return data, True
 
-    async def wait_for_login(
-        self, state: str, timeout: int = 180
-    ) -> Tuple[Dict, bool]:
+    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
         """
         description:
-            等待抖音登录结果，轮询检查登录状态（公共方法，供服务端调用）
-            
+            等待TikTok登录结果，轮询检查登录状态（公共方法，供服务端调用）
+
             服务端在用户点击授权后，调用此方法轮询等待登录结果。
             此方法会持续轮询直到登录成功或超时。
         parameters:
@@ -832,7 +623,7 @@ class DouyinLogin(AsyncClient):
         for _ in range(total_checks):
             status, response = await self._request_raw(
                 "POST",
-                "/api/unified-login/douyin/wait-login",
+                "/api/unified-login/tiktok/wait-login",
                 json={"state": state},
             )
 
@@ -863,13 +654,7 @@ class GitLabLogin(AsyncClient):
         # 将auth_url返回给前端，让用户点击授权
         # 2. 等待登录结果（在服务端轮询）
         user_info, success = await gitlab.wait_for_login(state, timeout=180)
-        if success and user_info.get("refresh_token"):
-            # 使用refresh_token刷新access_token
-            token_data, success = await gitlab.refresh_access_token(user_info.get("refresh_token"))
-    
-    # 测试场景（仅用于本地测试，会打开浏览器）
-    gitlab = GitLabLogin(api_key="your_api_key")
-    user_info, success = await gitlab.login()
+        print(user_info, success)
     ```
     """
 
@@ -880,7 +665,7 @@ class GitLabLogin(AsyncClient):
         """
         description:
             获取GitLab OAuth授权URL（公共方法，供服务端调用）
-            
+
             服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
             获取到state后，使用wait_for_login方法等待登录结果。
         return:
@@ -897,53 +682,11 @@ class GitLabLogin(AsyncClient):
             return None, False
         return data, True
 
-    async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
-        """
-        description:
-            仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
-            
-            注意：此方法仅用于本地测试场景，会自动打开浏览器。
-            在生产环境的服务端场景中，应该使用get_auth_url和wait_for_login方法。
-        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)
-
-    def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
-        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 = 180
-    ) -> Tuple[Dict, bool]:
+    async def wait_for_login(self, state: str, timeout: int = 180) -> Tuple[Dict, bool]:
         """
         description:
             等待GitLab登录结果，轮询检查登录状态（公共方法，供服务端调用）
-            
+
             服务端在用户点击授权后，调用此方法轮询等待登录结果。
             此方法会持续轮询直到登录成功或超时。
         parameters:
@@ -977,7 +720,7 @@ class GitLabLogin(AsyncClient):
         """
         description:
             使用refresh_token刷新access_token
-            
+
             注意：GitLab 采用 token rotation（令牌轮换）机制，每次刷新时会返回新的 refresh_token，
             旧的 refresh_token 会立即失效。必须保存新的 refresh_token 并替换旧的。
         parameters:
@@ -1041,9 +784,7 @@ class SMSLogin(AsyncClient):
         )
         return bool(success)
 
-    async def _wait_for_login(
-        self, phone: str, timeout: int
-    ) -> Tuple[Dict, bool]:
+    async def _wait_for_login(self, phone: str, timeout: int) -> Tuple[Dict, bool]:
         """
         等待短信登录结果
 
@@ -1133,9 +874,7 @@ class EmailLogin(AsyncClient):
         )
         return bool(success)
 
-    async def _wait_for_login(
-        self, email: str, timeout: int
-    ) -> Tuple[Dict, bool]:
+    async def _wait_for_login(self, email: str, timeout: int) -> Tuple[Dict, bool]:
         """
         等待邮箱登录结果
 

{pixelarraythirdparty-1.2.3 → pixelarraythirdparty-1.2.5}/pixelarraythirdparty.egg-info/PKG-INFO

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

{pixelarraythirdparty-1.2.3 → pixelarraythirdparty-1.2.5}/pyproject.toml

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