yuehua-ziniao-webdriver 0.1.0__py3-none-any.whl

yuehua_ziniao_webdriver/process.py

@@ -0,0 +1,270 @@
+"""进程管理模块
+
+提供紫鸟客户端进程的启动、关闭和管理功能。
+"""
+
+import os
+import time
+import subprocess
+import logging
+from typing import List, Optional
+
+from .types import VersionType
+from .utils import is_windows, is_mac, is_linux
+from .exceptions import BrowserStartError, ProcessError
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessManager:
+    """进程管理器
+    
+    负责紫鸟客户端进程的启动和关闭。
+    """
+    
+    def __init__(
+        self,
+        client_path: str,
+        socket_port: int,
+        version: VersionType = "v6"
+    ) -> None:
+        """初始化进程管理器
+        
+        Args:
+            client_path: 客户端可执行文件路径
+            socket_port: 通信端口
+            version: 客户端版本
+        """
+        self.client_path = client_path
+        self.socket_port = socket_port
+        self.version = version
+        self.process: Optional[subprocess.Popen] = None
+        
+        logger.debug(
+            f"初始化进程管理器：client_path={client_path}, "
+            f"socket_port={socket_port}, version={version}"
+        )
+    
+    def kill_existing_process(self, force: bool = False) -> bool:
+        """关闭已存在的紫鸟客户端进程
+        
+        Args:
+            force: 是否强制关闭（不询问用户），默认 False
+            
+        Returns:
+            bool: 成功关闭返回 True，用户取消返回 False
+            
+        Raises:
+            ProcessError: 进程关闭失败
+        """
+        # 确认是否继续
+        if not force:
+            try:
+                confirmation = input(
+                    "在启动之前，需要先关闭紫鸟浏览器的主进程，"
+                    "确定要终止进程吗？(y/n): "
+                )
+                if confirmation.lower() != 'y':
+                    logger.info("用户取消关闭进程")
+                    return False
+            except (EOFError, KeyboardInterrupt):
+                logger.info("用户取消关闭进程")
+                return False
+        
+        try:
+            if is_windows():
+                process_name = self._get_windows_process_name()
+                logger.info(f"关闭 Windows 进程：{process_name}")
+                result = os.system(f'taskkill /f /t /im {process_name}')
+                time.sleep(3)
+                
+                if result != 0:
+                    logger.warning(f"关闭进程返回非零状态码：{result}")
+                
+            elif is_mac():
+                logger.info("关闭 macOS 进程：ziniao")
+                os.system('killall ziniao')
+                time.sleep(3)
+                
+            elif is_linux():
+                logger.info("关闭 Linux 进程：ziniaobrowser")
+                os.system('killall ziniaobrowser')
+                time.sleep(3)
+            
+            else:
+                raise ProcessError("不支持的操作系统平台")
+            
+            logger.info("成功关闭已存在的进程")
+            return True
+            
+        except Exception as e:
+            error_msg = f"关闭进程失败：{e}"
+            logger.error(error_msg)
+            raise ProcessError(error_msg, {"error": str(e)})
+    
+    def _get_windows_process_name(self) -> str:
+        """获取 Windows 平台的进程名称
+        
+        Returns:
+            str: 进程名称
+        """
+        if self.version == "v5":
+            return "SuperBrowser.exe"
+        else:
+            return "ziniao.exe"
+    
+    def start_browser(self, wait_time: int = 5) -> None:
+        """启动紫鸟客户端
+        
+        Args:
+            wait_time: 启动后等待时间（秒），默认 5 秒
+            
+        Raises:
+            BrowserStartError: 启动失败
+        """
+        try:
+            cmd = self._build_start_command()
+            
+            logger.info(f"启动客户端：{' '.join(cmd)}")
+            
+            # 启动进程
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            
+            logger.info(f"客户端进程已启动，PID: {self.process.pid}")
+            
+            # 等待客户端启动完成
+            logger.debug(f"等待 {wait_time} 秒让客户端完成启动...")
+            time.sleep(wait_time)
+            
+            # 检查进程是否仍在运行
+            if self.process.poll() is not None:
+                # 进程已退出
+                stdout, stderr = self.process.communicate()
+                error_msg = (
+                    f"客户端启动后立即退出，退出码：{self.process.returncode}\n"
+                    f"stdout: {stdout.decode('utf-8', errors='ignore')}\n"
+                    f"stderr: {stderr.decode('utf-8', errors='ignore')}"
+                )
+                logger.error(error_msg)
+                raise BrowserStartError(error_msg)
+            
+            logger.info("客户端启动成功")
+            
+        except BrowserStartError:
+            raise
+        except Exception as e:
+            error_msg = f"启动客户端失败：{e}"
+            logger.error(error_msg)
+            raise BrowserStartError(error_msg, {"error": str(e)})
+    
+    def _build_start_command(self) -> List[str]:
+        """构建启动命令
+        
+        Returns:
+            List[str]: 命令参数列表
+            
+        Raises:
+            ProcessError: 不支持的平台
+        """
+        port_str = str(self.socket_port)
+        
+        if is_windows():
+            return [
+                self.client_path,
+                '--run_type=web_driver',
+                '--ipc_type=http',
+                f'--port={port_str}'
+            ]
+        
+        elif is_mac():
+            return [
+                'open',
+                '-a',
+                self.client_path,
+                '--args',
+                '--run_type=web_driver',
+                '--ipc_type=http',
+                f'--port={port_str}'
+            ]
+        
+        elif is_linux():
+            return [
+                self.client_path,
+                '--no-sandbox',
+                '--run_type=web_driver',
+                '--ipc_type=http',
+                f'--port={port_str}'
+            ]
+        
+        else:
+            raise ProcessError("不支持的操作系统平台")
+    
+    def is_running(self) -> bool:
+        """检查客户端进程是否正在运行
+        
+        Returns:
+            bool: 运行中返回 True
+        """
+        if self.process is None:
+            return False
+        
+        return self.process.poll() is None
+    
+    def get_pid(self) -> Optional[int]:
+        """获取进程 PID
+        
+        Returns:
+            Optional[int]: PID，如果进程未启动返回 None
+        """
+        if self.process is None:
+            return None
+        return self.process.pid
+    
+    def terminate(self, wait_timeout: int = 10) -> bool:
+        """终止客户端进程
+        
+        Args:
+            wait_timeout: 等待进程终止的超时时间（秒）
+            
+        Returns:
+            bool: 成功终止返回 True
+        """
+        if self.process is None:
+            logger.debug("进程未启动，无需终止")
+            return True
+        
+        if not self.is_running():
+            logger.debug("进程已退出，无需终止")
+            return True
+        
+        try:
+            logger.info(f"终止进程 PID: {self.process.pid}")
+            self.process.terminate()
+            
+            # 等待进程退出
+            try:
+                self.process.wait(timeout=wait_timeout)
+                logger.info("进程已正常终止")
+                return True
+            except subprocess.TimeoutExpired:
+                # 强制杀死
+                logger.warning(f"进程 {wait_timeout} 秒内未退出，强制杀死")
+                self.process.kill()
+                self.process.wait()
+                logger.info("进程已强制杀死")
+                return True
+                
+        except Exception as e:
+            logger.error(f"终止进程失败：{e}")
+            return False
+    
+    def __repr__(self) -> str:
+        return (
+            f"ProcessManager(client_path='{self.client_path}', "
+            f"socket_port={self.socket_port}, version='{self.version}', "
+            f"running={self.is_running()})"
+        )

yuehua_ziniao_webdriver/store.py

@@ -0,0 +1,429 @@
+"""店铺管理模块
+
+提供店铺的打开、关闭、列表获取和搜索功能。
+"""
+
+import json
+import logging
+import uuid
+from typing import List, Optional, Dict, Any
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from .types import Store, StoreOpenOptions, BrowserStartResult
+from .http_client import HttpClient
+from .browser import BrowserSession
+from .utils import fuzzy_match, exact_match
+from .exceptions import (
+    StoreNotFoundError,
+    MultipleStoresFoundError,
+    StoreOperationError,
+    UnsupportedVersionError
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StoreManager:
+    """店铺管理器
+    
+    负责店铺的各种操作。
+    """
+    
+    def __init__(
+        self,
+        http_client: HttpClient,
+        user_info: Dict[str, str]
+    ) -> None:
+        """初始化店铺管理器
+        
+        Args:
+            http_client: HTTP 客户端
+            user_info: 用户信息字典（company, username, password）
+        """
+        self.http_client = http_client
+        self.user_info = user_info
+        self._store_list_cache: Optional[List[Store]] = None
+        
+        logger.debug("初始化店铺管理器")
+    
+    def get_store_list(self, use_cache: bool = False) -> List[Store]:
+        """获取店铺列表
+        
+        Args:
+            use_cache: 是否使用缓存，默认 False
+            
+        Returns:
+            List[Store]: 店铺列表
+            
+        Raises:
+            StoreOperationError: 获取失败
+        """
+        # 如果使用缓存且缓存存在
+        if use_cache and self._store_list_cache is not None:
+            logger.debug("使用缓存的店铺列表")
+            return self._store_list_cache
+        
+        request_id = str(uuid.uuid4())
+        data = {
+            "action": "getBrowserList",
+            "requestId": request_id
+        }
+        data.update(self.user_info)
+        
+        logger.info("获取店铺列表...")
+        
+        result = self.http_client.send_request(data)
+        
+        if result is None:
+            raise StoreOperationError(
+                "获取",
+                "all",
+                message="HTTP 请求返回 None"
+            )
+        
+        status_code = result.get("statusCode")
+        
+        if status_code == 0:
+            browser_list = result.get("browserList", [])
+            logger.info(f"成功获取店铺列表，共 {len(browser_list)} 个店铺")
+            
+            # 更新缓存
+            self._store_list_cache = browser_list
+            
+            return browser_list
+        else:
+            error_msg = result.get("message", "未知错误")
+            logger.error(f"获取店铺列表失败：statusCode={status_code}, message={error_msg}")
+            raise StoreOperationError(
+                "获取列表",
+                "all",
+                status_code=status_code,
+                message=error_msg
+            )
+    
+    def find_stores_by_name(
+        self,
+        name: str,
+        exact_match_mode: bool = False,
+        use_cache: bool = True
+    ) -> List[Store]:
+        """通过名称搜索店铺
+        
+        Args:
+            name: 店铺名称
+            exact_match_mode: 是否精确匹配，False 则模糊匹配
+            use_cache: 是否使用缓存的店铺列表，默认 True
+            
+        Returns:
+            List[Store]: 匹配的店铺列表
+        """
+        logger.debug(
+            f"搜索店铺：name='{name}', exact_match={exact_match_mode}"
+        )
+        
+        # 获取店铺列表
+        store_list = self.get_store_list(use_cache=use_cache)
+        
+        # 搜索匹配的店铺
+        matched_stores: List[Store] = []
+        
+        for store in store_list:
+            store_name = store.get("browserName", "")
+            
+            if exact_match_mode:
+                if exact_match(store_name, name):
+                    matched_stores.append(store)
+            else:
+                if fuzzy_match(store_name, name):
+                    matched_stores.append(store)
+        
+        logger.debug(f"找到 {len(matched_stores)} 个匹配的店铺")
+        
+        return matched_stores
+    
+    def open_store(
+        self,
+        store_identifier: str,
+        **options
+    ) -> BrowserSession:
+        """打开店铺
+        
+        Args:
+            store_identifier: 店铺标识（browserOauth 或 browserId）
+            **options: 打开店铺的选项（参见 StoreOpenOptions）
+            
+        Returns:
+            BrowserSession: 浏览器会话对象
+            
+        Raises:
+            StoreOperationError: 打开失败
+        """
+        request_id = str(uuid.uuid4())
+        
+        # 构建请求数据
+        data: Dict[str, Any] = {
+            "action": "startBrowser",
+            "isWaitPluginUpdate": options.get("isWaitPluginUpdate", 0),
+            "isHeadless": options.get("isHeadless", 0),
+            "requestId": request_id,
+            "isWebDriverReadOnlyMode": options.get("isWebDriverReadOnlyMode", 0),
+            "cookieTypeLoad": options.get("cookieTypeLoad", 0),
+            "cookieTypeSave": options.get("cookieTypeSave", 0),
+            "runMode": options.get("runMode", "1"),
+            "isLoadUserPlugin": options.get("isLoadUserPlugin", False),
+            "pluginIdType": options.get("pluginIdType", 1),
+            "privacyMode": options.get("privacyMode", 0),
+        }
+        data.update(self.user_info)
+        
+        # 确定使用 browserId 还是 browserOauth
+        if store_identifier.isdigit():
+            data["browserId"] = store_identifier
+        else:
+            data["browserOauth"] = store_identifier
+        
+        # 注入 JS 信息（如果提供）
+        js_info = options.get("jsInfo", "")
+        if len(str(js_info)) > 2:
+            data["injectJsInfo"] = json.dumps(js_info)
+        
+        logger.info(f"打开店铺：{store_identifier}")
+        
+        # 发送请求
+        result = self.http_client.send_request(data)
+        
+        if result is None:
+            raise StoreOperationError(
+                "打开",
+                store_identifier,
+                message="HTTP 请求返回 None"
+            )
+        
+        status_code = result.get("statusCode")
+        
+        if status_code == 0:
+            # 打开成功
+            debugging_port = result.get("debuggingPort")
+            browser_oauth = result.get("browserOauth", store_identifier)
+            ip_check_url = result.get("ipDetectionPage")
+            launcher_page = result.get("launcherPage")
+            
+            # 获取店铺名称（尝试从缓存的店铺列表中查找）
+            store_name = self._get_store_name(browser_oauth)
+            
+            logger.info(
+                f"店铺打开成功：{store_name} (OAuth: {browser_oauth}, "
+                f"Port: {debugging_port})"
+            )
+            
+            # 创建浏览器会话
+            session = BrowserSession(
+                port=debugging_port,
+                store_id=browser_oauth,
+                store_name=store_name,
+                ip_check_url=ip_check_url,
+                launcher_page=launcher_page,
+                close_callback=lambda sid: self.close_store(sid)
+            )
+            
+            return session
+            
+        else:
+            error_msg = result.get("message", "未知错误")
+            logger.error(
+                f"打开店铺失败：{store_identifier}, "
+                f"statusCode={status_code}, message={error_msg}"
+            )
+            raise StoreOperationError(
+                "打开",
+                store_identifier,
+                status_code=status_code,
+                message=error_msg
+            )
+    
+    def open_store_by_name(
+        self,
+        store_name: str,
+        exact_match_mode: bool = False,
+        **options
+    ) -> BrowserSession:
+        """通过店铺名称打开店铺
+        
+        Args:
+            store_name: 店铺名称
+            exact_match_mode: 是否精确匹配，默认 False（模糊匹配）
+            **options: 打开店铺的选项
+            
+        Returns:
+            BrowserSession: 浏览器会话对象
+            
+        Raises:
+            StoreNotFoundError: 未找到匹配的店铺
+            MultipleStoresFoundError: 找到多个匹配的店铺
+            StoreOperationError: 打开失败
+        """
+        logger.info(f"通过名称打开店铺：'{store_name}'")
+        
+        # 搜索店铺
+        matched_stores = self.find_stores_by_name(
+            store_name,
+            exact_match_mode=exact_match_mode
+        )
+        
+        # 检查结果
+        if len(matched_stores) == 0:
+            raise StoreNotFoundError(store_name, "名称")
+        
+        if len(matched_stores) > 1:
+            store_names = [s.get("browserName", "") for s in matched_stores]
+            raise MultipleStoresFoundError(
+                store_name,
+                len(matched_stores),
+                store_names
+            )
+        
+        # 打开店铺
+        store = matched_stores[0]
+        store_oauth = store.get("browserOauth")
+        
+        if not store_oauth:
+            raise StoreOperationError(
+                "打开",
+                store_name,
+                message="店铺 OAuth 标识为空"
+            )
+        
+        return self.open_store(store_oauth, **options)
+    
+    def open_stores_by_names(
+        self,
+        store_names: List[str],
+        max_workers: int = 3,
+        exact_match_mode: bool = False,
+        **options
+    ) -> Dict[str, BrowserSession]:
+        """并发打开多个店铺（通过店铺名称）
+        
+        Args:
+            store_names: 店铺名称列表
+            max_workers: 最大并发数，默认 3
+            exact_match_mode: 是否精确匹配，默认 False
+            **options: 打开店铺的选项
+            
+        Returns:
+            Dict[str, BrowserSession]: 店铺名称到浏览器会话的映射
+            
+        Note:
+            如果某个店铺打开失败，会记录错误但不会中断其他店铺的打开。
+            返回的字典中只包含成功打开的店铺。
+        """
+        logger.info(f"并发打开 {len(store_names)} 个店铺，最大并发数：{max_workers}")
+        
+        sessions: Dict[str, BrowserSession] = {}
+        
+        def open_single_store(name: str) -> tuple[str, Optional[BrowserSession]]:
+            """打开单个店铺的辅助函数"""
+            try:
+                session = self.open_store_by_name(
+                    name,
+                    exact_match_mode=exact_match_mode,
+                    **options
+                )
+                return (name, session)
+            except Exception as e:
+                logger.error(f"打开店铺失败：{name}, 错误：{e}")
+                return (name, None)
+        
+        # 使用线程池并发打开
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # 提交所有任务
+            futures = {
+                executor.submit(open_single_store, name): name
+                for name in store_names
+            }
+            
+            # 收集结果
+            for future in as_completed(futures):
+                name, session = future.result()
+                if session is not None:
+                    sessions[name] = session
+                    logger.info(f"店铺打开成功：{name}")
+                else:
+                    logger.warning(f"店铺打开失败：{name}")
+        
+        logger.info(
+            f"并发打开完成：成功 {len(sessions)}/{len(store_names)} 个店铺"
+        )
+        
+        return sessions
+    
+    def close_store(self, store_id: str) -> None:
+        """关闭店铺
+        
+        Args:
+            store_id: 店铺 ID/OAuth
+            
+        Raises:
+            StoreOperationError: 关闭失败
+        """
+        request_id = str(uuid.uuid4())
+        data = {
+            "action": "stopBrowser",
+            "requestId": request_id,
+            "duplicate": 0,
+            "browserOauth": store_id
+        }
+        data.update(self.user_info)
+        
+        logger.info(f"关闭店铺：{store_id}")
+        
+        result = self.http_client.send_request(data)
+        
+        if result is None:
+            raise StoreOperationError(
+                "关闭",
+                store_id,
+                message="HTTP 请求返回 None"
+            )
+        
+        status_code = result.get("statusCode")
+        
+        if status_code == 0:
+            logger.info(f"店铺关闭成功：{store_id}")
+        else:
+            error_msg = result.get("message", "未知错误")
+            logger.error(
+                f"关闭店铺失败：{store_id}, "
+                f"statusCode={status_code}, message={error_msg}"
+            )
+            raise StoreOperationError(
+                "关闭",
+                store_id,
+                status_code=status_code,
+                message=error_msg
+            )
+    
+    def _get_store_name(self, store_oauth: str) -> str:
+        """从缓存中获取店铺名称
+        
+        Args:
+            store_oauth: 店铺 OAuth 标识
+            
+        Returns:
+            str: 店铺名称，未找到返回 OAuth
+        """
+        if self._store_list_cache:
+            for store in self._store_list_cache:
+                if store.get("browserOauth") == store_oauth:
+                    return store.get("browserName", store_oauth)
+        
+        return store_oauth
+    
+    def clear_cache(self) -> None:
+        """清除店铺列表缓存"""
+        logger.debug("清除店铺列表缓存")
+        self._store_list_cache = None
+    
+    def __repr__(self) -> str:
+        cache_size = len(self._store_list_cache) if self._store_list_cache else 0
+        return f"StoreManager(cached_stores={cache_size})"