pixelarraythirdparty 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

pixelarraythirdparty/product/product.py

@@ -15,44 +15,33 @@ class ProductManagerAsync(AsyncClient):
         sort_order: int,
     ):
         """
-        创建产品（异步版本）
-
-        功能说明：
+        description:
             创建新的产品，支持订阅产品和一次性产品，产品信息包括名称、描述、价格、分类等。
-
-        输入参数：
-            name (str): 产品名称，必填
-            description (str): 产品描述，必填
-            price (float): 产品价格（元），必填
-            category (str): 产品分类，必填
-            status (str): 产品状态，必填，可选值：
-                - "ACTIVE": 激活
-                - "INACTIVE": 停用
-            is_subscription (bool): 是否为订阅产品，必填
-            subscription_period (str): 订阅周期，必填，可选值：
-                - "MONTHLY": 月付
-                - "YEARLY": 年付
-            features (str): 产品特性，JSON格式字符串，必填
-            sort_order (int): 排序权重，必填
-
-        返回字段：
-            data (dict): 产品信息
-                - id (int): 产品ID
-                - name (str): 产品名称
-                - description (str): 产品描述
-                - price (float): 产品价格（元）
-                - category (str): 产品分类
-                - status (str): 产品状态
-                - is_subscription (bool): 是否为订阅产品
-                - subscription_period (str): 订阅周期
-                - features (str): 产品特性（JSON格式）
-                - sort_order (int): 排序权重
-                - created_at (str): 产品创建时间
-                - updated_at (str): 产品更新时间
-            success (bool): 操作是否成功
-
-        异常情况：
-            - 产品创建失败：返回错误信息"产品创建失败"
+        parameters:
+            name(str): 产品名称
+            description(str): 产品描述
+            price(float): 产品价格（元）
+            category(str): 产品分类
+            status(str): 产品状态，可选值："ACTIVE"（激活）、"INACTIVE"（停用）
+            is_subscription(bool): 是否为订阅产品
+            subscription_period(str): 订阅周期，可选值："MONTHLY"（月付）、"YEARLY"（年付）
+            features(str): 产品特性，JSON格式字符串
+            sort_order(int): 排序权重
+        return:
+            data(dict): 产品信息
+                - id(int): 产品ID
+                - name(str): 产品名称
+                - description(str): 产品描述
+                - price(float): 产品价格（元）
+                - category(str): 产品分类
+                - status(str): 产品状态
+                - is_subscription(bool): 是否为订阅产品
+                - subscription_period(str): 订阅周期
+                - features(str): 产品特性（JSON格式）
+                - sort_order(int): 排序权重
+                - created_at(str): 产品创建时间
+                - updated_at(str): 产品更新时间
+            success(bool): 操作是否成功
         """
         data = {
             "name": name,
@@ -79,42 +68,21 @@ class ProductManagerAsync(AsyncClient):
         name: str = None,
     ):
         """
-        获取产品列表（异步版本）
-
-        功能说明：
+        description:
             分页查询产品列表，支持按状态、分类和名称进行筛选。
-
-        输入参数：
-            page (int, 可选): 页码，默认为1，最小值为1
-            page_size (int, 可选): 每页数量，默认为10，范围为1-1000
-            status (str, 可选): 产品状态筛选，可选值：
-                - "ACTIVE": 激活
-                - "INACTIVE": 停用
-            category (str, 可选): 产品分类筛选
-            name (str, 可选): 产品名称搜索，支持模糊匹配
-
-        返回字段：
-            data (dict): 产品列表信息
-                - products (list): 产品列表
-                    - id (int): 产品ID
-                    - name (str): 产品名称
-                    - description (str): 产品描述
-                    - price (float): 产品价格（元）
-                    - category (str): 产品分类
-                    - status (str): 产品状态
-                    - is_subscription (bool): 是否为订阅产品
-                    - subscription_period (str): 订阅周期
-                    - features (str): 产品特性（JSON格式）
-                    - sort_order (int): 排序权重
-                    - created_at (str): 产品创建时间
-                    - updated_at (str): 产品更新时间
-                - total (int): 总产品数量
-                - page (int): 当前页码
-                - page_size (int): 每页数量
-            success (bool): 操作是否成功
-
-        异常情况：
-            - 获取产品列表失败：返回错误信息"获取产品列表失败"
+        parameters:
+            page(int): 页码
+            page_size(int): 每页数量
+            status(str): 产品状态筛选，可选值："ACTIVE"（激活）、"INACTIVE"（停用）
+            category(str): 产品分类筛选
+            name(str): 产品名称搜索，支持模糊匹配
+        return:
+            data(dict): 产品列表信息
+                - products(list): 产品列表
+                - total(int): 总产品数量
+                - page(int): 当前页码
+                - page_size(int): 每页数量
+            success(bool): 操作是否成功
         """
         params = {
             "page": page,
@@ -133,33 +101,13 @@ class ProductManagerAsync(AsyncClient):
 
     async def get_product_detail(self, product_id: str):
         """
-        获取产品详情（异步版本）
-
-        功能说明：
+        description:
             根据产品ID获取产品的详细信息。
-
-        输入参数：
-            product_id (str): 产品ID，必填
-
-        返回字段：
-            data (dict): 产品详细信息
-                - id (int): 产品ID
-                - name (str): 产品名称
-                - description (str): 产品描述
-                - price (float): 产品价格（元）
-                - category (str): 产品分类
-                - status (str): 产品状态
-                - is_subscription (bool): 是否为订阅产品
-                - subscription_period (str): 订阅周期
-                - features (str): 产品特性（JSON格式）
-                - sort_order (int): 排序权重
-                - created_at (str): 产品创建时间
-                - updated_at (str): 产品更新时间
-            success (bool): 操作是否成功
-
-        异常情况：
-            - 产品不存在：返回错误信息"产品不存在"
-            - 获取产品详情失败：返回错误信息"获取产品详情失败"
+        parameters:
+            product_id(str): 产品ID
+        return:
+            data(dict): 产品详细信息
+            success(bool): 操作是否成功
         """
         data, success = await self._request("GET", f"/api/products/{product_id}")
         if not success:
@@ -180,46 +128,34 @@ class ProductManagerAsync(AsyncClient):
         sort_order: int,
     ):
         """
-        更新产品信息（异步版本）
-
-        功能说明：
+        description:
             更新指定产品的信息，包括名称、描述、价格、状态等。
-
-        输入参数：
-            product_id (str): 产品ID，必填
-            name (str): 产品名称，必填
-            description (str): 产品描述，必填
-            price (float): 产品价格（元），必填
-            category (str): 产品分类，必填
-            status (str): 产品状态，必填，可选值：
-                - "ACTIVE": 激活
-                - "INACTIVE": 停用
-            is_subscription (bool): 是否为订阅产品，必填
-            subscription_period (str): 订阅周期，必填，可选值：
-                - "MONTHLY": 月付
-                - "YEARLY": 年付
-            features (str): 产品特性，JSON格式字符串，必填
-            sort_order (int): 排序权重，必填
-
-        返回字段：
-            data (dict): 更新后的产品信息
-                - id (int): 产品ID
-                - name (str): 产品名称
-                - description (str): 产品描述
-                - price (float): 产品价格（元）
-                - category (str): 产品分类
-                - status (str): 产品状态
-                - is_subscription (bool): 是否为订阅产品
-                - subscription_period (str): 订阅周期
-                - features (str): 产品特性（JSON格式）
-                - sort_order (int): 排序权重
-                - created_at (str): 产品创建时间
-                - updated_at (str): 产品更新时间
-            success (bool): 操作是否成功
-
-        异常情况：
-            - 产品不存在：返回错误信息"产品不存在"
-            - 产品更新失败：返回错误信息"产品更新失败"
+        parameters:
+            product_id(str): 产品ID
+            name(str): 产品名称
+            description(str): 产品描述
+            price(float): 产品价格（元）
+            category(str): 产品分类
+            status(str): 产品状态，可选值："ACTIVE"（激活）、"INACTIVE"（停用）
+            is_subscription(bool): 是否为订阅产品
+            subscription_period(str): 订阅周期，可选值："MONTHLY"（月付）、"YEARLY"（年付）
+            features(str): 产品特性，JSON格式字符串
+            sort_order(int): 排序权重
+        return:
+            data(dict): 更新后的产品信息
+                - id(int): 产品ID
+                - name(str): 产品名称
+                - description(str): 产品描述
+                - price(float): 产品价格（元）
+                - category(str): 产品分类
+                - status(str): 产品状态
+                - is_subscription(bool): 是否为订阅产品
+                - subscription_period(str): 订阅周期
+                - features(str): 产品特性（JSON格式）
+                - sort_order(int): 排序权重
+                - created_at(str): 产品创建时间
+                - updated_at(str): 产品更新时间
+            success(bool): 操作是否成功
         """
         data = {
             "name": name,
@@ -241,21 +177,13 @@ class ProductManagerAsync(AsyncClient):
 
     async def delete_product(self, product_id: str):
         """
-        删除产品（异步版本）
-
-        功能说明：
+        description:
             根据产品ID删除指定的产品记录。
-
-        输入参数：
-            product_id (str): 产品ID，必填
-
-        返回字段：
-            data (None): 删除成功时返回None
-            success (bool): 操作是否成功
-
-        异常情况：
-            - 产品不存在：返回错误信息"产品不存在"
-            - 删除产品失败：返回错误信息"删除产品失败"
+        parameters:
+            product_id(str): 产品ID
+        return:
+            data(None): 删除成功时返回None
+            success(bool): 操作是否成功
         """
         data, success = await self._request("DELETE", f"/api/products/{product_id}")
         if not success:
@@ -264,21 +192,12 @@ class ProductManagerAsync(AsyncClient):
 
     async def get_product_categories(self):
         """
-        获取产品分类列表（异步版本）
-
-        功能说明：
+        description:
             获取所有可用的产品分类列表。
-
-        输入参数：
-            无
-
-        返回字段：
-            data (dict): 产品分类信息
-                - categories (list): 产品分类列表，如["subscription", "service", "addon"]
-            success (bool): 操作是否成功
-
-        异常情况：
-            - 获取产品分类失败：返回错误信息"获取产品分类失败"
+        return:
+            data(dict): 产品分类信息
+                - categories(list): 产品分类列表，如["subscription", "service", "addon"]
+            success(bool): 操作是否成功
         """
         data, success = await self._request("GET", "/api/products/categories/list")
         if not success:

pixelarraythirdparty/unified_login/__init__.py

@@ -1,16 +1,4 @@
-from .unified_login import (
-    ThirdPartyAuthUrlRequest,
-    ThirdPartyAuthUrlResponse,
-    ThirdPartyLoginRequest,
-    ThirdPartyLoginResponse,
-    UnifiedLoginClientAsync,
-)
+from .unified_login import GoogleLogin, WechatLogin, GitHubLogin
 
-__all__ = [
-    "ThirdPartyAuthUrlRequest",
-    "ThirdPartyAuthUrlResponse",
-    "ThirdPartyLoginRequest",
-    "ThirdPartyLoginResponse",
-    "UnifiedLoginClientAsync",
-]
+__all__ = ["GoogleLogin", "WechatLogin", "GitHubLogin"]
 

pixelarraythirdparty/unified_login/unified_login.py

@@ -1,18 +1,270 @@
-from client.pypi.pixelarraythirdparty.client import AsyncClient
+import asyncio
+import urllib.parse
+import webbrowser
+from typing import Dict, Optional, Tuple
+
+from pixelarraythirdparty.client import AsyncClient
 
 
 class GoogleLogin(AsyncClient):
-    async def _get_auth_url(self):
-        pass
-        
-    async def _get_code_from_redirect_uri(self, redirect_uri: str):
-        pass
+    """
+    Google OAuth2 登录客户端
+
+    使用示例:
+    ```
+    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]:
+        data, success = await self._request(
+            "POST", "/api/unified-login/google/auth-url"
+        )
+        if not success:
+            return None, False
+        auth_url = data.get("auth_url")
+        if not auth_url:
+            return None, False
+        return data, True
+
+    async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
+        """
+        仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，
+        终端端轮询等待登录结果
+
+        :param timeout: 等待用户完成授权的超时时间（秒）
+        """
+        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_google_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_google_login(
+        self, state: str, timeout: int
+    ) -> Tuple[Dict, 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 {}, False
+
+
+class WechatLogin(AsyncClient):
+    """
+    微信 OAuth2 登录客户端
+
+    使用示例:
+    ```
+    wechat = WechatLogin(api_key="your_api_key")
+    user_info, success = await wechat.login()
+    ```
+    """
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key)
+
+    async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+        data, success = await self._request(
+            "POST", "/api/unified-login/wechat/auth-url"
+        )
+        if not success:
+            return None, False
+        auth_url = data.get("auth_url")
+        if not auth_url:
+            return None, False
+        return data, True
+
+    async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
+        """
+        仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，
+        终端端轮询等待登录结果
+
+        :param timeout: 等待用户完成授权的超时时间（秒）
+        """
+        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_wechat_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_wechat_login(
+        self, state: str, timeout: int
+    ) -> Tuple[Dict, 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/wechat/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 {}, False
+
+
+class GitHubLogin(AsyncClient):
+    """
+    GitHub OAuth2 登录客户端
+
+    使用示例:
+    ```
+    github = GitHubLogin(api_key="your_api_key")
+    user_info, success = await github.login()
+    ```
+    """
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key)
+
+    async def _get_auth_url(self) -> Tuple[Optional[Dict[str, str]], bool]:
+        data, success = await self._request(
+            "POST", "/api/unified-login/github/auth-url"
+        )
+        if not success:
+            return None, False
+        auth_url = data.get("auth_url")
+        if not auth_url:
+            return None, False
+        return data, True
+
+    async def login(self, timeout: int = 180) -> Tuple[Dict, bool]:
+        """
+        仿 Supabase CLI 的一键登录流程：打开浏览器完成授权，
+        终端端轮询等待登录结果
+
+        :param timeout: 等待用户完成授权的超时时间（秒）
+        """
+        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_github_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_github_login(
+        self, state: str, timeout: int
+    ) -> Tuple[Dict, 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 {}, False
 
-    async def _get_user_info(self, token: str) -> dict:
-        pass
 
-    async def login(self) -> dict:
-        pass
+class UnifiedLogin(AsyncClient):
+    def __init__(self, api_key: str):
+        super().__init__(api_key)
 
-    async def logout(self) -> dict:
-        pass
+    async def login(self, provider: str, timeout: int = 180) -> Tuple[Dict, bool]:
+        if provider == "google":
+            return await GoogleLogin(self.api_key).login(timeout)
+        elif provider == "wechat":
+            return await WechatLogin(self.api_key).login(timeout)
+        elif provider == "github":
+            return await GitHubLogin(self.api_key).login(timeout)
+        else:
+            return {}, False