pixelarraythirdparty 1.2.1__tar.gz → 1.2.3__tar.gz

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

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

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

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

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

@@ -15,7 +15,21 @@ class OAuth2Login(AsyncClient):
     
     使用示例:
     ```
-    # Google登录
+    # 服务端使用场景（推荐）
+    google = OAuth2Login(
+        api_key="your_api_key",
+        provider="google"
+    )
+    # 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)
+    
+    # 测试场景（仅用于本地测试，会打开浏览器）
     google = OAuth2Login(
         api_key="your_api_key",
         provider="google"
@@ -123,10 +137,13 @@ class OAuth2Login(AsyncClient):
             )
         return endpoint
     
-    async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+    async def get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
         """
         description:
-            获取OAuth授权URL
+            获取OAuth授权URL（公共方法，供服务端调用）
+            
+            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
+            获取到state后，使用wait_for_login方法等待登录结果。
         return:
             auth_data(dict, optional): 授权数据字典，包含auth_url和state
             success(bool): 是否成功
@@ -161,15 +178,18 @@ class OAuth2Login(AsyncClient):
             return None
         return None
     
-    async def _wait_for_login(
-        self, state: str, timeout: int
+    async def wait_for_login(
+        self, state: str, timeout: int = 180
     ) -> Tuple[Dict, bool]:
         """
         description:
-            等待登录结果，轮询检查登录状态
+            等待登录结果，轮询检查登录状态（公共方法，供服务端调用）
+            
+            服务端在用户点击授权后，调用此方法轮询等待登录结果。
+            此方法会持续轮询直到登录成功或超时。
         parameters:
-            state(str): 登录状态标识
-            timeout(int): 超时时间（秒）
+            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
+            timeout(int, optional): 超时时间（秒），默认为180
         return:
             user_info(dict): 用户信息字典
             success(bool): 是否成功
@@ -199,13 +219,16 @@ class OAuth2Login(AsyncClient):
         """
         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()
+        auth_data, success = await self.get_auth_url()
         if not success or not auth_data:
             return {}, False
         
@@ -217,12 +240,16 @@ class OAuth2Login(AsyncClient):
         
         webbrowser.open(auth_url, new=2)
         
-        return await self._wait_for_login(state, timeout)
+        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。
         parameters:
             refresh_token(str): OAuth refresh_token
         return:
@@ -250,27 +277,42 @@ class GoogleLogin(AsyncClient):
 
     使用示例:
     ```
+    # 服务端使用场景（推荐）
     google = GoogleLogin(api_key="your_api_key")
-    user_info, success = await google.login()
+    # 1. 获取授权URL
+    auth_data, success = await google.get_auth_url()
     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")
+        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")
+            
+            # 使用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()
     ```
     """
 
     def __init__(self, api_key: str):
         super().__init__(api_key)
 
-    async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+    async def get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
         """
         description:
-            获取Google OAuth授权URL
+            获取Google OAuth授权URL（公共方法，供服务端调用）
+            
+            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
+            获取到state后，使用wait_for_login方法等待登录结果。
         return:
             auth_data(dict, optional): 授权数据字典，包含auth_url和state
             success(bool): 是否成功
@@ -289,13 +331,16 @@ class GoogleLogin(AsyncClient):
         """
         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()
+        auth_data, success = await self.get_auth_url()
         if not success or not auth_data:
             return {}, False
 
@@ -307,7 +352,7 @@ class GoogleLogin(AsyncClient):
 
         webbrowser.open(auth_url, new=2)
 
-        return await self._wait_for_google_login(state, timeout)
+        return await self.wait_for_login(state, timeout)
 
     def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
         if not auth_url:
@@ -322,15 +367,18 @@ class GoogleLogin(AsyncClient):
             return None
         return None
 
-    async def _wait_for_google_login(
-        self, state: str, timeout: int
+    async def wait_for_login(
+        self, state: str, timeout: int = 180
     ) -> Tuple[Dict, bool]:
         """
         description:
-            等待Google登录结果，轮询检查登录状态
+            等待Google登录结果，轮询检查登录状态（公共方法，供服务端调用）
+            
+            服务端在用户点击授权后，调用此方法轮询等待登录结果。
+            此方法会持续轮询直到登录成功或超时。
         parameters:
-            state(str): 登录状态标识
-            timeout(int): 超时时间（秒）
+            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
+            timeout(int, optional): 超时时间（秒），默认为180
         return:
             user_info(dict): 用户信息字典
             success(bool): 是否成功
@@ -385,21 +433,42 @@ class WechatLogin(AsyncClient):
 
     使用示例:
     ```
+    # 服务端使用场景（推荐）
     wechat = WechatLogin(api_key="your_api_key")
     # PC端扫码登录
-    user_info, success = await wechat.login(login_type="desktop")
+    auth_data, success = await wechat.get_auth_url(login_type="desktop")
+    if success:
+        auth_url = auth_data.get("auth_url")
+        state = auth_data.get("state")
+        # 将auth_url返回给前端，让用户扫码授权
+        # 等待登录结果
+        user_info, success = await wechat.wait_for_login(state, timeout=180, login_type="desktop")
+    
     # 微信公众号登录（手机端）
-    user_info, success = await wechat.login(login_type="mobile")
+    auth_data, success = await wechat.get_auth_url(login_type="mobile")
+    if success:
+        auth_url = auth_data.get("auth_url")
+        state = auth_data.get("state")
+        # 将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")
     ```
     """
 
     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，然后将URL返回给前端让用户点击授权。
+            获取到state后，使用wait_for_login方法等待登录结果。
         parameters:
             login_type(str, optional): 登录类型，desktop表示PC端扫码登录，mobile表示微信公众号登录，默认为desktop
         return:
@@ -425,6 +494,9 @@ class WechatLogin(AsyncClient):
         """
         description:
             仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，终端端轮询等待登录结果
+            
+            注意：此方法仅用于本地测试场景，会自动打开浏览器。
+            在生产环境的服务端场景中，应该使用get_auth_url和wait_for_login方法。
         parameters:
             login_type(str, optional): 登录类型，desktop表示PC端扫码登录，mobile表示微信公众号登录，默认为desktop
             timeout(int, optional): 等待用户完成授权的超时时间（秒），默认为180
@@ -432,7 +504,7 @@ class WechatLogin(AsyncClient):
             user_info(dict): 用户信息字典
             success(bool): 是否成功
         """
-        auth_data, success = await self._get_auth_url(login_type)
+        auth_data, success = await self.get_auth_url(login_type)
         if not success or not auth_data:
             return {}, False
 
@@ -444,7 +516,7 @@ class WechatLogin(AsyncClient):
 
         webbrowser.open(auth_url, new=2)
 
-        return await self._wait_for_wechat_login(state, timeout, login_type)
+        return await self.wait_for_login(state, timeout, login_type)
 
     def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
         """
@@ -467,15 +539,18 @@ class WechatLogin(AsyncClient):
             return None
         return None
 
-    async def _wait_for_wechat_login(
-        self, state: str, timeout: int, login_type: str = "desktop"
+    async def wait_for_login(
+        self, state: str, timeout: int = 180, login_type: str = "desktop"
     ) -> Tuple[Dict, bool]:
         """
         description:
-            等待微信登录结果，轮询检查登录状态
+            等待微信登录结果，轮询检查登录状态（公共方法，供服务端调用）
+            
+            服务端在用户点击授权后，调用此方法轮询等待登录结果。
+            此方法会持续轮询直到登录成功或超时。
         parameters:
-            state(str): 登录状态标识
-            timeout(int): 超时时间（秒）
+            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
+            timeout(int, optional): 超时时间（秒），默认为180
             login_type(str, optional): 登录类型，desktop表示PC端扫码登录，mobile表示微信公众号登录，默认为desktop
         return:
             user_info(dict): 用户信息字典
@@ -514,6 +589,18 @@ class GitHubLogin(AsyncClient):
 
     使用示例:
     ```
+    # 服务端使用场景（推荐）
+    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)
+    
+    # 测试场景（仅用于本地测试，会打开浏览器）
     github = GitHubLogin(api_key="your_api_key")
     user_info, success = await github.login()
     ```
@@ -522,10 +609,13 @@ class GitHubLogin(AsyncClient):
     def __init__(self, api_key: str):
         super().__init__(api_key)
 
-    async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+    async def get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
         """
         description:
-            获取GitHub OAuth授权URL
+            获取GitHub OAuth授权URL（公共方法，供服务端调用）
+            
+            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
+            获取到state后，使用wait_for_login方法等待登录结果。
         return:
             auth_data(dict, optional): 授权数据字典，包含auth_url和state
             success(bool): 是否成功
@@ -544,13 +634,16 @@ class GitHubLogin(AsyncClient):
         """
         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()
+        auth_data, success = await self.get_auth_url()
         if not success or not auth_data:
             return {}, False
 
@@ -562,7 +655,7 @@ class GitHubLogin(AsyncClient):
 
         webbrowser.open(auth_url, new=2)
 
-        return await self._wait_for_github_login(state, timeout)
+        return await self.wait_for_login(state, timeout)
 
     def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
         """
@@ -585,15 +678,18 @@ class GitHubLogin(AsyncClient):
             return None
         return None
 
-    async def _wait_for_github_login(
-        self, state: str, timeout: int
+    async def wait_for_login(
+        self, state: str, timeout: int = 180
     ) -> Tuple[Dict, bool]:
         """
         description:
-            等待GitHub登录结果，轮询检查登录状态
+            等待GitHub登录结果，轮询检查登录状态（公共方法，供服务端调用）
+            
+            服务端在用户点击授权后，调用此方法轮询等待登录结果。
+            此方法会持续轮询直到登录成功或超时。
         parameters:
-            state(str): 登录状态标识
-            timeout(int): 超时时间（秒）
+            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
+            timeout(int, optional): 超时时间（秒），默认为180
         return:
             user_info(dict): 用户信息字典
             success(bool): 是否成功
@@ -625,6 +721,18 @@ class DouyinLogin(AsyncClient):
 
     使用示例:
     ```
+    # 服务端使用场景（推荐）
+    douyin = DouyinLogin(api_key="your_api_key")
+    # 1. 获取授权URL
+    auth_data, success = await douyin.get_auth_url()
+    if success:
+        auth_url = auth_data.get("auth_url")
+        state = auth_data.get("state")
+        # 将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()
     ```
@@ -633,10 +741,13 @@ class DouyinLogin(AsyncClient):
     def __init__(self, api_key: str):
         super().__init__(api_key)
 
-    async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+    async def get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
         """
         description:
-            获取抖音OAuth授权URL
+            获取抖音OAuth授权URL（公共方法，供服务端调用）
+            
+            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
+            获取到state后，使用wait_for_login方法等待登录结果。
         return:
             auth_data(dict, optional): 授权数据字典，包含auth_url和state
             success(bool): 是否成功
@@ -655,13 +766,16 @@ class DouyinLogin(AsyncClient):
         """
         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()
+        auth_data, success = await self.get_auth_url()
         if not success or not auth_data:
             return {}, False
 
@@ -673,7 +787,7 @@ class DouyinLogin(AsyncClient):
 
         webbrowser.open(auth_url, new=2)
 
-        return await self._wait_for_douyin_login(state, timeout)
+        return await self.wait_for_login(state, timeout)
 
     def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
         """
@@ -696,15 +810,18 @@ class DouyinLogin(AsyncClient):
             return None
         return None
 
-    async def _wait_for_douyin_login(
-        self, state: str, timeout: int
+    async def wait_for_login(
+        self, state: str, timeout: int = 180
     ) -> Tuple[Dict, bool]:
         """
         description:
-            等待抖音登录结果，轮询检查登录状态
+            等待抖音登录结果，轮询检查登录状态（公共方法，供服务端调用）
+            
+            服务端在用户点击授权后，调用此方法轮询等待登录结果。
+            此方法会持续轮询直到登录成功或超时。
         parameters:
-            state(str): 登录状态标识
-            timeout(int): 超时时间（秒）
+            state(str): 登录状态标识，从get_auth_url返回的auth_data中获取
+            timeout(int, optional): 超时时间（秒），默认为180
         return:
             user_info(dict): 用户信息字典
             success(bool): 是否成功
@@ -736,6 +853,21 @@ class GitLabLogin(AsyncClient):
 
     使用示例:
     ```
+    # 服务端使用场景（推荐）
+    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)
+        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()
     ```
@@ -744,7 +876,17 @@ class GitLabLogin(AsyncClient):
     def __init__(self, api_key: str):
         super().__init__(api_key)
 
-    async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+    async def get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+        """
+        description:
+            获取GitLab OAuth授权URL（公共方法，供服务端调用）
+            
+            服务端应该调用此方法获取授权URL，然后将URL返回给前端让用户点击授权。
+            获取到state后，使用wait_for_login方法等待登录结果。
+        return:
+            auth_data(dict, optional): 授权数据字典，包含auth_url和state
+            success(bool): 是否成功
+        """
         data, success = await self._request(
             "POST", "/api/unified-login/gitlab/auth-url"
         )
@@ -757,12 +899,18 @@ class GitLabLogin(AsyncClient):
 
     async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
         """
-        仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，
-        终端端轮询等待登录结果
-
-        :param timeout: 等待用户完成授权的超时时间（秒）
+        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()
+        auth_data, success = await self.get_auth_url()
         if not success or not auth_data:
             return {}, False
 
@@ -774,7 +922,7 @@ class GitLabLogin(AsyncClient):
 
         webbrowser.open(auth_url, new=2)
 
-        return await self._wait_for_gitlab_login(state, timeout)
+        return await self.wait_for_login(state, timeout)
 
     def _extract_state(self, auth_url: Optional[str]) -> Optional[str]:
         if not auth_url:
@@ -789,9 +937,22 @@ class GitLabLogin(AsyncClient):
             return None
         return None
 
-    async def _wait_for_gitlab_login(
-        self, state: str, timeout: int
+    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
 
@@ -816,6 +977,9 @@ class GitLabLogin(AsyncClient):
         """
         description:
             使用refresh_token刷新access_token
+            
+            注意：GitLab 采用 token rotation（令牌轮换）机制，每次刷新时会返回新的 refresh_token，
+            旧的 refresh_token 会立即失效。必须保存新的 refresh_token 并替换旧的。
         parameters:
             refresh_token(str): GitLab OAuth refresh_token
         return:

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

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

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

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