mcp-query-table 0.3.11__tar.gz → 0.3.13__tar.gz

{mcp_query_table-0.3.11 → mcp_query_table-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp_query_table
-Version: 0.3.11
+Version: 0.3.13
 Summary: query table from website, support MCP
 Author-email: wukan <wu-kan@163.com>
 License: MIT License
@@ -29,11 +29,12 @@ Keywords: eastmoney,iwencai,mcp,playwright,table,tdx
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Requires-Python: >=3.10
+Requires-Dist: fastmcp
 Requires-Dist: loguru
-Requires-Dist: mcp
 Requires-Dist: pandas
 Requires-Dist: playwright
 Requires-Dist: playwright-stealth>=2.0.0
+Requires-Dist: psutil
 Requires-Dist: tabulate
 Description-Content-Type: text/markdown
 

{mcp_query_table-0.3.11 → mcp_query_table-0.3.13}/mcp_query_table/__init__.py

@@ -1,7 +1,7 @@
 from ._version import __version__
 
 from .enums import QueryType, Site, Provider
-from .tool import BrowserManager, query, chat
+from .tool import query, chat
 
 TIMEOUT = 1000 * 60 * 3  # 3分钟，在抓取EventStream数据时等待数据返回，防止外层30秒超时
 TIMEOUT_60 = 1000 * 60  # 1分钟

{mcp_query_table-0.3.11 → mcp_query_table-0.3.13}/mcp_query_table/__main__.py

@@ -1,5 +1,6 @@
-import getpass
+import asyncio
 
+from mcp_query_table.playwright_helper import get_chrome_use_data
 from mcp_query_table.server import serve
 
 
@@ -17,7 +18,7 @@ def main():
     parser.add_argument("--executable_path", type=str, help="浏览器路径",
                         nargs="?", default=r'C:\Program Files\Google\Chrome\Application\chrome.exe')
     parser.add_argument("--user_data_dir", type=str, help="浏览器用户数据目录",
-                        nargs="?", default=rf'C:\Users\{getpass.getuser()}\AppData\Local\Google\Chrome\User Data')
+                        nargs="?", default=f'{get_chrome_use_data()}')
     parser.add_argument("--transport", type=str, help="传输类型",
                         default='stdio', choices=['stdio', 'sse', 'streamable-http'])
     parser.add_argument("--host", type=str, help="MCP服务端绑定地址",
@@ -25,9 +26,10 @@ def main():
     parser.add_argument("--port", type=int, help="MCP服务端绑定端口",
                         default='8000')
     args = parser.parse_args()
-    serve(args.format, args.endpoint,
-          args.executable_path, args.user_data_dir,
-          args.transport, args.host, args.port)
+
+    asyncio.run(serve(args.format,
+                      args.endpoint, args.executable_path, args.user_data_dir,
+                      args.transport, args.host, args.port))
 
 
 if __name__ == "__main__":

mcp_query_table-0.3.13/mcp_query_table/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.13"

mcp_query_table-0.3.13/mcp_query_table/playwright_helper.py

@@ -0,0 +1,351 @@
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Literal
+from urllib.parse import urlparse
+
+import psutil
+from loguru import logger
+from playwright.async_api import async_playwright
+from playwright.sync_api import sync_playwright
+from playwright_stealth import Stealth
+
+
+def get_chrome_path() -> str:
+    """Chrome可执行文件路径"""
+    if sys.platform == "darwin":
+        return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+    elif sys.platform == "win32":
+        return r"C:\Program Files\Google\Chrome\Application\chrome.exe"
+    elif sys.platform.startswith("linux"):
+        return "/usr/bin/google-chrome"
+    return shutil.which('google-chrome')
+
+
+def get_edge_path() -> str:
+    """Edge可执行文件路径"""
+    if sys.platform == "darwin":
+        return "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+    elif sys.platform == "win32":
+        return r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"
+    elif sys.platform.startswith("linux"):
+        return "/usr/bin/microsoft-edge"
+    return shutil.which('microsoft-edge')
+
+
+def get_edge_use_data():
+    """Edge用户配置路径"""
+    if sys.platform == "darwin":
+        return Path.home() / "Library/Application Support/Google/Chrome"
+    elif sys.platform == "win32":
+        return Path.home() / r"AppData\Local\Google\Chrome\User Data"
+    elif sys.platform.startswith("linux"):
+        return Path.home() / ".config/google-chrome"
+    return None
+
+
+def get_chrome_use_data():
+    """Chrome用户配置路径"""
+    if sys.platform == "darwin":
+        return Path.home() / "Library/Application Support/Microsoft Edge"
+    elif sys.platform == "win32":
+        return Path.home() / r"AppData\Local\Microsoft\Edge\User Data"
+    elif sys.platform.startswith("linux"):
+        return Path.home() / ".config/microsoft-edge"
+    return None
+
+
+def get_browser(proc_name: Literal["chrome.exe", "msedge.exe"], port: int | None = None) -> psutil.Process | None:
+    """查进程"""
+    for proc in psutil.process_iter(["name", "cmdline", "exe"]):
+        name = proc.info["name"].lower()
+        if proc_name in name:
+            exe_path = proc.info.get("exe", "") or ""
+
+            if port is None:
+                return proc
+            else:
+                if any(f"--remote-debugging-port={port}" in arg for arg in proc.info["cmdline"]):
+                    return proc
+    return None
+
+
+def kill_browsers(proc_name: Literal["chrome.exe", "msedge.exe"]) -> None:
+    """Edge需要退出所有进程，再次启动进程才能生效"""
+    for proc in psutil.process_iter(["name", "cmdline", "exe"]):
+        name = proc.info["name"].lower()
+        if proc_name in name:
+            if proc.is_running():
+                try:
+                    proc.kill()
+                except psutil.NoSuchProcess:
+                    pass
+
+
+def start_browser(browser_path: str, port: int, devtools: bool, user_data_dir: str | None = None):
+    """启动浏览器进程"""
+    command = [browser_path, f'--remote-debugging-port={port}', '--start-maximized']
+    if devtools:
+        command.append('--auto-open-devtools-for-tabs')
+    if user_data_dir:
+        # chrome不能使用默认配置，因为安全限制
+        command.append(f'--user-data-dir={user_data_dir}')
+    return subprocess.Popen(command)
+
+
+def is_local_url(url: str) -> bool:
+    """判断url是否是本地地址"""
+    for local in ('localhost', '127.0.0.1', "::1"):
+        if local in url.lower():
+            return True
+    return False
+
+
+def is_cdp_url(url: str) -> bool:
+    """判断url是否是CDP地址"""
+    if url.startswith('ws://') or url.startswith('wss://'):
+        return False
+    return True
+
+
+def is_url(url: str) -> bool:
+    urls = (
+        "devtools://",
+        "chrome-extension://",
+        "extension://",
+        "chrome://",
+        "edge://",
+    )
+    for u in urls:
+        if url.startswith(u):
+            return False
+    return True
+
+
+class BaseBrowser:
+    def __init__(self, endpoint: str | None, executable_path: str | None = None, devtools: bool = False, user_data_dir: str | None = None):
+        """连接参数
+
+        Parameters
+        ----------
+        endpoint:
+            浏览器CDP地址或服务器WS地址
+        executable_path:
+            Chrome或Edge的绝对路径
+        devtools:
+            是否显示开发者工具
+        user_data_dir
+            用户数据。可解决登录问题
+
+        Examples
+        --------
+        # python退出chrome也自动退出,需提前`playwright install chromium`
+        async with AsyncBrowser(endpoint=None, user_data_dir="D:\\user_data") as browser:
+            pass
+
+        # 本地先启动chrome进程，然后使用CDP协议进行控制
+        # chrome一定要另外提供`user_data_dir`
+        # edge需要完全退出才能启动时启动CDP
+        async with AsyncBrowser(endpoint="http://127.0.0.1:9222", executable_path=get_chrome_path(), user_data_dir="D:\\user_data") as browser:
+            pass
+
+        # 连接到远程的Playwright Server
+        # 参考 https://playwright.dev/python/docs/docker#connecting-to-the-server
+        with SyncBrowser(endpoint="ws://127.0.0.1:3000") as browser:
+            pass
+
+        """
+        self.endpoint = endpoint
+        self.executable_path = executable_path
+        self.devtools = devtools
+        self.user_data_dir = user_data_dir
+
+        self.headless = False
+        self.playwright = None
+        self.browser = None
+
+        self.timeout = 20000
+        self.slow_mo = 1000
+
+    def _start_chrome(self, sleep: int = 5):
+        if self.executable_path:
+            name = Path(self.executable_path).name
+            port = urlparse(self.endpoint).port
+            proc = get_browser(name, port)
+            if proc is None:
+                kill_browsers(name)
+                ret = start_browser(self.executable_path, port, self.devtools, self.user_data_dir)
+                time.sleep(sleep)
+        else:
+            logger.warning("连接本地CDP时未提供executable_path，需手工启动带参数的浏览器")
+
+
+class AsyncBrowser(BaseBrowser):
+    async def __aenter__(self):
+        await self._launch()
+
+        async def get_page():
+            contexts = self.browser.contexts
+            if contexts:
+                context = contexts[0]
+            else:
+                context = await self.browser.new_context()
+
+            await Stealth().apply_stealth_async(context)
+
+            pages = context.pages
+            if pages:
+                for page in pages:
+                    if is_url(page.url):
+                        return page
+
+            return await context.new_page()
+
+        self.browser.get_page = get_page
+
+        return self.browser
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.browser:
+            await self.browser.close()
+        if self.playwright:
+            await self.playwright.stop()
+
+    async def _launch(self):
+        """启动并连接"""
+        self.playwright = await async_playwright().start()
+        if self.endpoint is None:
+            await self._connect_to_launch()
+            return
+        elif is_local_url(self.endpoint) and is_cdp_url(self.endpoint):
+            self._start_chrome()
+
+        kwargs = {
+            "timeout": self.timeout,
+            "slow_mo": self.slow_mo,
+        }
+        if is_cdp_url(self.endpoint):
+            self.browser = await self.playwright.chromium.connect_over_cdp(self.endpoint, **kwargs)
+        else:
+            # https://playwright.dev/python/docs/docker#connecting-to-the-server
+            self.browser = await self.playwright.chromium.connect(self.endpoint, **kwargs)
+
+    async def _connect_to_launch(self) -> None:
+        logger.info("executable_path={}", self.executable_path)
+        kwargs = {
+            "executable_path": self.executable_path,
+            "headless": self.headless,
+            "timeout": self.timeout,
+            "slow_mo": self.slow_mo,
+            # "devtools": self.devtools,
+        }
+        if self.user_data_dir:
+            logger.info("user_data_dir={}", self.user_data_dir)
+            try:
+                context = await self.playwright.chromium.launch_persistent_context(user_data_dir=self.user_data_dir, **kwargs)
+                self.browser = context.browser
+            except:
+                raise ConnectionError(f"launch失败，可能已经有浏览器已经打开了数据目录。{self.user_data_dir}")
+        else:
+            logger.warning("未指定浏览器用户数据目录，部分需要的网站可能无法使用")
+            self.browser = await self.playwright.chromium.launch(**kwargs)
+
+
+class SyncBrowser(BaseBrowser):
+
+    def __enter__(self):
+        self._launch()
+
+        def get_page():
+            contexts = self.browser.contexts
+            if contexts:
+                context = contexts[0]
+            else:
+                context = self.browser.new_context()
+
+            Stealth().apply_stealth_sync(context)
+
+            pages = context.pages
+            if pages:
+                for page in pages:
+                    if is_url(page.url):
+                        return page
+
+            return context.new_page()
+
+        self.browser.get_page = get_page
+
+        return self.browser
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.browser:
+            self.browser.close()
+        if self.playwright:
+            self.playwright.stop()
+
+    def _launch(self):
+        """启动并连接"""
+        self.playwright = sync_playwright().start()
+        if self.endpoint is None:
+            self._connect_to_launch()
+            return
+        elif is_local_url(self.endpoint) and is_cdp_url(self.endpoint):
+            self._start_chrome()
+
+        kwargs = {
+            "timeout": self.timeout,
+            "slow_mo": self.slow_mo,
+        }
+        if is_cdp_url(self.endpoint):
+            self.browser = self.playwright.chromium.connect_over_cdp(self.endpoint, **kwargs)
+        else:
+            # https://playwright.dev/python/docs/docker#connecting-to-the-server
+            self.browser = self.playwright.chromium.connect(self.endpoint, **kwargs)
+
+    def _connect_to_launch(self) -> None:
+        logger.info("executable_path={}", self.executable_path)
+        kwargs = {
+            "executable_path": self.executable_path,
+            "headless": self.headless,
+            "timeout": self.timeout,
+            "slow_mo": self.slow_mo,
+            # "devtools": self.devtools,
+        }
+        if self.user_data_dir:
+            logger.info("user_data_dir={}", self.user_data_dir)
+            try:
+                context = self.playwright.chromium.launch_persistent_context(user_data_dir=self.user_data_dir, **kwargs)
+                self.browser = context.browser
+            except:
+                raise ConnectionError(f"launch失败，可能已经有浏览器已经打开了数据目录。{self.user_data_dir}")
+        else:
+            logger.warning("未指定浏览器用户数据目录，部分需要的网站可能无法使用")
+            self.browser = self.playwright.chromium.launch(**kwargs)
+
+
+async def async_main():
+    async with AsyncBrowser(endpoint="http://127.0.0.1:9222", executable_path=get_chrome_path(), user_data_dir="D:\\user_data") as browser:
+        context = await browser.new_context(proxy={"server": "http://127.0.0.1:10808"})
+        page = await browser.new_page()
+        await page.goto("https://ipw.cn/")
+        page = await context.new_page()
+        await page.goto("https://ipw.cn/")
+        input("AAA")
+
+
+def sync_main():
+    with SyncBrowser(endpoint="http://127.0.0.1:9222", executable_path=get_chrome_path(), user_data_dir="D:\\user_data") as browser:
+        context = browser.new_context(proxy={"server": "http://127.0.0.1:10808"})
+        page = browser.new_page()
+        page.goto("https://ipw.cn/")
+        page = context.new_page()
+        page.goto("https://ipw.cn/")
+        input("BBB")
+
+# if __name__ == "__main__":
+#     import asyncio
+#
+#     asyncio.run(async_main())
+#     sync_main()

{mcp_query_table-0.3.11 → mcp_query_table-0.3.13}/mcp_query_table/server.py

@@ -1,12 +1,12 @@
 from typing import Annotated, List
 
+import fastmcp
 from loguru import logger
-from mcp.server.fastmcp import FastMCP
 from pydantic import Field
 
 from mcp_query_table import QueryType, Site, query as qt_query, chat as qt_chat
 from mcp_query_table.enums import Provider
-from mcp_query_table.tool import BrowserManager
+from mcp_query_table.playwright_helper import AsyncBrowser
 
 
 class QueryServer:
@@ -14,18 +14,16 @@ class QueryServer:
         self.format: str = "markdown"
         self.browser = None
 
-    def start(self, format, endpoint, executable_path, user_data_dir):
+    async def start(self, format, endpoint, executable_path, user_data_dir):
         self.format: str = format
-        self.browser = BrowserManager(endpoint=endpoint,
-                                      executable_path=executable_path,
-                                      user_data_dir=user_data_dir,
-                                      devtools=False,
-                                      headless=True)
+        self.browser = await AsyncBrowser(endpoint=endpoint,
+                                          executable_path=executable_path,
+                                          devtools=False,
+                                          user_data_dir=user_data_dir).__aenter__()
 
     async def query(self, query_input: str, query_type: QueryType, max_page: int, rename: bool, site: Site):
         page = await self.browser.get_page()
         df = await qt_query(page, query_input, query_type, max_page, rename, site)
-        self.browser.release_page(page)
 
         if self.format == 'csv':
             return df.to_csv()
@@ -37,12 +35,10 @@ class QueryServer:
     async def chat(self, prompt: str, create: bool, files: List[str], provider: Provider):
         page = await self.browser.get_page()
         txt = await qt_chat(page, prompt, create, files, provider)
-        self.browser.release_page(page)
         return txt
 
 
-# !!!log_level这一句非常重要，否则Cline/MCP Server/Tools工作不正常
-mcp = FastMCP("query_table_mcp", log_level="ERROR")
+mcp = fastmcp.FastMCP("query_table_mcp")
 qsv = QueryServer()
 
 
@@ -71,16 +67,15 @@ async def chat(
     return await qsv.chat(prompt, create, files, provider)
 
 
-def serve(format, endpoint, executable_path, user_data_dir, transport, host, port):
-    qsv.start(format, endpoint, executable_path, user_data_dir)
+async def serve(format, endpoint, executable_path, user_data_dir, transport, host, port):
     logger.info(f"{endpoint=}")
     logger.info(f"{executable_path=}")
     logger.info(f"{user_data_dir=}")
-    if transport == 'sse':
-        logger.info(f"{transport=},{format=},{host=},{port=}")
-    else:
-        logger.info(f"{transport=},{format=}")
+    await qsv.start(format, endpoint, executable_path, user_data_dir)
 
-    mcp.settings.host = host
-    mcp.settings.port = port
-    mcp.run(transport=transport)
+    if transport == "stdio":
+        logger.info(f"{transport=},{format=}")
+        await mcp.run_async(transport=transport)
+    else:
+        logger.info(f"{transport=},{format=},{host=},{port=}")
+        await mcp.run_async(transport=transport, host=host, port=port)

mcp_query_table-0.3.13/mcp_query_table/tool.py

@@ -0,0 +1,96 @@
+from urllib.parse import quote
+
+import pandas as pd
+from playwright.async_api import Page
+
+from mcp_query_table.enums import QueryType, Site, Provider
+
+
+async def query(
+        page: Page,
+        query_input: str = "收盘价>100元",
+        query_type: QueryType = QueryType.CNStock,
+        max_page: int = 5,
+        rename: bool = False,
+        site: Site = Site.THS,
+) -> pd.DataFrame:
+    """查询表格
+
+    Parameters
+    ----------
+    page : playwright.sync_api.Page
+        页面
+    query_input : str, optional
+        查询条件, by default "收盘价>100元"
+    query_type : QueryType, optional
+        查询类型, by default QueryType.astock
+    max_page : int, optional
+        最大页数, by default 5
+    rename: bool
+        是否重命名列名, by default False
+    site : Site, optional
+        站点, by default Site.iwencai
+
+    Returns
+    -------
+    pd.DataFrame
+        查询结果
+
+    """
+    query_input = quote(query_input.strip(), safe='')
+
+    if site == Site.EastMoney:
+        from mcp_query_table.sites.eastmoney import query
+        return await query(page, query_input, query_type, max_page, rename)
+    if site == Site.THS:
+        from mcp_query_table.sites.iwencai import query
+        return await query(page, query_input, query_type, max_page, rename)
+    if site == Site.TDX:
+        from mcp_query_table.sites.tdx import query
+        return await query(page, query_input, query_type, max_page, rename)
+
+    raise ValueError(f"未支持的站点:{site}")
+
+
+async def chat(
+        page: Page,
+        prompt: str = "9.9大还是9.11大？",
+        create: bool = False,
+        files: list[str] | None = None,
+        provider: Provider = Provider.Nami) -> str:
+    """大语言对话
+
+    Parameters
+    ----------
+    page : playwright.sync_api.Page
+        页面
+    prompt : str, optional
+        对话内容, by default "9.9大还是9.11大？"
+    create : bool, optional
+        是否创建新对话, by default False
+    files : list[str] | None, optional
+        上传的文件列表。不同网站支持程度不同
+    provider : Provider, optional
+        提供商, by default Provider.N
+
+    Returns
+    -------
+    str
+        对话结果
+
+    """
+    # 空列表转None
+    if files is None:
+        files = []
+
+    if provider == Provider.Nami:
+        from mcp_query_table.providers.n import chat
+        return await chat(page, prompt, create, files)
+    if provider == Provider.YuanBao:
+        from mcp_query_table.providers.yuanbao import chat
+        return await chat(page, prompt, create, files)
+    if provider == Provider.BaiDu:
+        from mcp_query_table.providers.baidu import chat
+        return await chat(page, prompt, create, files)
+
+    raise ValueError(f"未支持的提供商:{provider}")

{mcp_query_table-0.3.11 → mcp_query_table-0.3.13}/pyproject.toml

@@ -15,9 +15,10 @@ classifiers = [
 dependencies = [
     "pandas",
     "loguru",
+    "psutil",
     "playwright",
     "playwright-stealth>=2.0.0", # https://github.com/Mattwmaster58/playwright_stealth
-    "mcp",
+    "fastmcp",
     "tabulate"
 ]
 dynamic = ["version"]

mcp_query_table-0.3.11/mcp_query_table/_version.py

@@ -1 +0,0 @@
-__version__ = "0.3.11"

mcp_query_table-0.3.11/mcp_query_table/tool.py

@@ -1,338 +0,0 @@
-import getpass
-import subprocess
-import sys
-import time
-from pathlib import Path
-from typing import Optional
-from urllib.parse import urlparse, quote
-
-import pandas as pd
-from loguru import logger
-from playwright.async_api import async_playwright, Playwright, Page
-from playwright_stealth import Stealth
-
-from mcp_query_table.enums import QueryType, Site, Provider
-
-
-def create_detached_process(command):
-    # 设置通用参数
-    kwargs = {}
-
-    if sys.platform == 'win32':
-        kwargs.update({
-            # 在PyCharm中运行还是会出现新建进程被关闭
-            'creationflags': subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
-        })
-    else:
-        # Unix-like 系统（Linux, macOS）特定设置
-        kwargs.update({
-            'start_new_session': True  # 创建新的会话
-        })
-    logger.info(f"Popen: {command}")
-    return subprocess.Popen(command, **kwargs)
-
-
-def is_local_url(url: str) -> bool:
-    """判断url是否是本地地址"""
-    for local in ('localhost', '127.0.0.1'):
-        if local in url.lower():
-            return True
-    return False
-
-
-def is_cdp_url(url: str) -> bool:
-    """判断url是否是CDP地址"""
-    if url.startswith('ws://') or url.startswith('wss://'):
-        return False
-    return True
-
-
-def get_executable_path(executable_path) -> Optional[str]:
-    """获取浏览器可执行文件路径"""
-    browsers = {
-        "default": executable_path,
-        "chrome.exe": r"C:\Program Files\Google\Chrome\Application\chrome.exe",
-        "msedge.exe": r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
-    }
-    for k, v in browsers.items():
-        if v is None:
-            continue
-        if Path(v).exists():
-            return v
-    return None
-
-
-def get_user_data_dir(user_data_dir) -> Optional[str]:
-    """获取浏览器可用户目录"""
-    browsers = {
-        "default": user_data_dir,
-        "chrome.exe": rf'C:\Users\{getpass.getuser()}\AppData\Local\Google\Chrome\User Data',  # 使用默认配置文件时无法创建CDP
-        "msedge.exe": rf"C:\Users\{getpass.getuser()}\AppData\Local\Microsoft\Edge\User Data",
-    }
-    for k, v in browsers.items():
-        if v is None:
-            continue
-        if Path(v).exists():
-            return v
-    return None
-
-
-class BrowserManager:
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.cleanup()
-
-    def __init__(self,
-                 endpoint: Optional[str],
-                 executable_path: Optional[str] = None,
-                 devtools: bool = False,
-                 headless: bool = True,
-                 user_data_dir: Optional[str] = None):
-        """
-
-        Parameters
-        ----------
-        endpoint:str or None
-            浏览器CDP地址/WS地址。
-            如果为None，则直接启动浏览器实例。可用无头模式。建议指定用户数据目录，否则可能无法使用某些需要登录的网站
-        executable_path:str
-            浏览器可执行文件路径。推荐使用chrome，因为Microsoft Edge必须在任务管理器中完全退出才能启动调试端口
-        devtools:bool
-            是否显示开发者工具
-        headless:bool
-            是否无头模式启动浏览器
-        user_data_dir:str
-            浏览器用户数据目录。无头模式。强烈建议指定用户数据目录，否则可能无法使用某些需要登录的网站
-
-        """
-        if devtools:
-            headless = False
-
-        self.endpoint = endpoint
-        self.executable_path = executable_path
-        self.devtools = devtools
-        self.headless = headless
-        self.user_data_dir = user_data_dir
-
-        self.playwright: Optional[Playwright] = None
-        self.browser = None
-        self.context = None
-        # 空闲page池
-        self.pages = []
-
-    async def cleanup(self):
-        if self.browser:
-            await self.browser.close()
-        if self.playwright:
-            await self.playwright.stop()
-
-    async def _connect_to_local(self) -> None:
-        """连接本地浏览器"""
-        port = urlparse(self.endpoint).port
-        executable_path = get_executable_path(self.executable_path)
-        name = Path(executable_path).name
-        command = [executable_path, f'--remote-debugging-port={port}', '--start-maximized']
-        if self.devtools:
-            command.append('--auto-open-devtools-for-tabs')
-        if self.user_data_dir:
-            command.append(f'--user-data-dir={self.user_data_dir}')
-        else:
-            logger.warning('Chrome必须另行指定`--user-data-dir`才能创建CDP连接')
-
-        for i in range(2):
-            try:
-                self.browser = await self.playwright.chromium.connect_over_cdp(self.endpoint,
-                                                                               timeout=10000, slow_mo=1000)
-                break
-            except:
-                if i == 0:
-                    create_detached_process(command)
-                    time.sleep(5)
-                    continue
-                if i == 1:
-                    raise ConnectionError(
-                        f"已提前打开了浏览器，但未开启远程调试端口？请关闭浏览器全部进程后重试 `taskkill /f /im {name}`")
-
-    async def _connect_to_remote(self) -> None:
-        """连接远程浏览器"""
-        try:
-            if is_cdp_url(self.endpoint):
-                self.browser = await self.playwright.chromium.connect_over_cdp(self.endpoint,
-                                                                               timeout=10000, slow_mo=1000)
-            else:
-                self.browser = await self.playwright.chromium.connect(self.endpoint,
-                                                                      timeout=10000, slow_mo=1000)
-        except:
-            raise ConnectionError(f"连接远程浏览器失败，请检查CDP/WS地址和端口是否正确。{self.endpoint}")
-
-    async def _connect_to_launch(self) -> None:
-        logger.info("executable_path={}", self.executable_path)
-        if self.user_data_dir:
-            logger.info("user_data_dir={}", self.user_data_dir)
-            try:
-                self.context = await self.playwright.chromium.launch_persistent_context(
-                    user_data_dir=self.user_data_dir,
-                    executable_path=self.executable_path,
-                    headless=self.headless,
-                    devtools=self.devtools,
-                    timeout=10000, slow_mo=1000)
-            except:
-                raise ConnectionError(f"launch失败，可能已经有浏览器已经打开了数据目录。{self.user_data_dir}")
-        else:
-            logger.warning("未指定浏览器用户数据目录，部分需要的网站可能无法使用")
-            self.browser = await self.playwright.chromium.launch(
-                executable_path=self.executable_path,
-                headless=self.headless,
-                devtools=self.devtools)
-
-    async def _launch(self) -> None:
-        """启动浏览器，并连接CDP协议
-
-        References
-        ----------
-        https://blog.csdn.net/qq_30576521/article/details/142370538
-
-        """
-        self.playwright = await async_playwright().start()
-        if self.endpoint is None:
-            await self._connect_to_launch()
-        elif is_local_url(self.endpoint) and is_cdp_url(self.endpoint):
-            await self._connect_to_local()
-        else:
-            await self._connect_to_remote()
-
-        if self.browser is None:
-            pass
-        elif len(self.browser.contexts) == 0:
-            self.context = await self.browser.new_context()
-        else:
-            self.context = self.browser.contexts[0]
-        # 爱问财，无头模式，需要使用 stealth 插件
-        await Stealth().apply_stealth_async(self.context)
-
-        # 复用打开的page
-        for page in self.context.pages:
-            # 防止开发者工具被使用
-            if page.url.startswith("devtools://"):
-                continue
-            # 防止chrome扩展被使用
-            if page.url.startswith("chrome-extension://"):
-                continue
-            # 防止edge扩展被使用
-            if page.url.startswith("extension://"):
-                continue
-            self.pages.append(page)
-
-    async def get_page(self) -> Page:
-        """获取可用Page。无空闲标签时会打开新标签"""
-        if self.context is None:
-            await self._launch()
-
-        # 反复取第一个tab
-        while len(self.pages) > 0:
-            page = self.pages.pop()
-            if page.is_closed():
-                continue
-            return page
-
-        # 不够，新建一个
-        return await self.context.new_page()
-
-    def release_page(self, page) -> None:
-        """用完的Page释放到池中。如果用完不放回，get_page会一直打开新标签"""
-        if page.is_closed():
-            return
-        # 放回
-        self.pages.append(page)
-
-
-async def query(
-        page: Page,
-        query_input: str = "收盘价>100元",
-        query_type: QueryType = QueryType.CNStock,
-        max_page: int = 5,
-        rename: bool = False,
-        site: Site = Site.THS,
-) -> pd.DataFrame:
-    """查询表格
-
-    Parameters
-    ----------
-    page : playwright.sync_api.Page
-        页面
-    query_input : str, optional
-        查询条件, by default "收盘价>100元"
-    query_type : QueryType, optional
-        查询类型, by default QueryType.astock
-    max_page : int, optional
-        最大页数, by default 5
-    rename: bool
-        是否重命名列名, by default False
-    site : Site, optional
-        站点, by default Site.iwencai
-
-    Returns
-    -------
-    pd.DataFrame
-        查询结果
-
-    """
-    query_input = quote(query_input.strip(), safe='')
-
-    if site == Site.EastMoney:
-        from mcp_query_table.sites.eastmoney import query
-        return await query(page, query_input, query_type, max_page, rename)
-    if site == Site.THS:
-        from mcp_query_table.sites.iwencai import query
-        return await query(page, query_input, query_type, max_page, rename)
-    if site == Site.TDX:
-        from mcp_query_table.sites.tdx import query
-        return await query(page, query_input, query_type, max_page, rename)
-
-    raise ValueError(f"未支持的站点:{site}")
-
-
-async def chat(
-        page: Page,
-        prompt: str = "9.9大还是9.11大？",
-        create: bool = False,
-        files: list[str] | None = None,
-        provider: Provider = Provider.Nami) -> str:
-    """大语言对话
-
-    Parameters
-    ----------
-    page : playwright.sync_api.Page
-        页面
-    prompt : str, optional
-        对话内容, by default "9.9大还是9.11大？"
-    create : bool, optional
-        是否创建新对话, by default False
-    files : list[str] | None, optional
-        上传的文件列表。不同网站支持程度不同
-    provider : Provider, optional
-        提供商, by default Provider.N
-
-    Returns
-    -------
-    str
-        对话结果
-
-    """
-    # 空列表转None
-    if files is None:
-        files = []
-
-    if provider == Provider.Nami:
-        from mcp_query_table.providers.n import chat
-        return await chat(page, prompt, create, files)
-    if provider == Provider.YuanBao:
-        from mcp_query_table.providers.yuanbao import chat
-        return await chat(page, prompt, create, files)
-    if provider == Provider.BaiDu:
-        from mcp_query_table.providers.baidu import chat
-        return await chat(page, prompt, create, files)
-
-    raise ValueError(f"未支持的提供商:{provider}")