mangoautomation 1.1.22__py3-none-any.whl → 1.1.24__py3-none-any.whl

mangoautomation/uidrives/web/async_web/_browser.py

@@ -1,112 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description: # @Time   : 2023-04-25 22:33
-# @Author : 毛鹏
-import asyncio
-import json
-import os.path
-import traceback
-from urllib.parse import urlparse
-
-from playwright._impl._errors import TimeoutError, Error, TargetClosedError
-
-from mangotools.decorator import async_method_callback
-from mangotools.models import MethodModel
-from ..._base_data import BaseData
-from ....exceptions import MangoAutomationError
-from ....exceptions.error_msg import ERROR_MSG_0049, ERROR_MSG_0013, ERROR_MSG_0058, ERROR_MSG_0059, ERROR_MSG_0010
-from ....tools import Meta
-
-
-class AsyncWebBrowser(metaclass=Meta):
-    """浏览器操作"""
-
-    def __init__(self, base_data: BaseData):
-        self.base_data = base_data
-
-    @async_method_callback('web', '浏览器操作', 0, [
-        MethodModel(n='等待时间', f='_time', p='请输入等待时间', d=True)])
-    async def w_wait_for_timeout(self, _time: int):
-        """强制等待"""
-        await asyncio.sleep(int(_time))
-
-    @async_method_callback('web', '浏览器操作', 1, [
-        MethodModel(n='url地址', f='url', p='请输入URL', d=True)])
-    async def w_goto(self, url: str):
-        """打开URL"""
-        try:
-            result = urlparse(url)
-            if not all([result.scheme, result.netloc]):
-                raise MangoAutomationError(*ERROR_MSG_0049)
-            await self.base_data.page.goto(url, timeout=60000)
-            await asyncio.sleep(2)
-        except TimeoutError as error:
-            self.base_data.log.debug(f'打开URL失败-1，类型：{type(error)}，失败详情：{error}')
-            raise MangoAutomationError(*ERROR_MSG_0013, value=(url,))
-        except TargetClosedError as error:
-            self.base_data.setup()
-            self.base_data.log.debug(f'打开URL失败-2，类型：{type(error)}，失败详情：{error}')
-            raise MangoAutomationError(*ERROR_MSG_0010, value=(url,))
-        except Error as error:
-            self.base_data.log.debug(
-                f'打开URL失败-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
-            raise MangoAutomationError(*ERROR_MSG_0058, value=(url,))
-
-    @async_method_callback('web', '浏览器操作', 2, [
-        MethodModel(n='存储路径', f='path', p='请输入截图名称', d=True)])
-    async def w_screenshot(self, path: str):
-        """整个页面截图"""
-        try:
-            await self.base_data.page.screenshot(path=os.path.join(self.base_data.screenshot_path, path), full_page=True, timeout=10000)
-        except (TargetClosedError, TimeoutError) as error:
-            self.base_data.log.debug(
-                f'截图出现异常失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
-            self.base_data.setup()
-            raise MangoAutomationError(*ERROR_MSG_0010)
-        except AttributeError as error:
-            self.base_data.log.debug(
-                f'截图出现异常失败-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
-            self.base_data.setup()
-            raise MangoAutomationError(*ERROR_MSG_0010)
-
-    @async_method_callback('web', '浏览器操作', 3)
-    async def w_alert(self):
-        """设置弹窗不予处理"""
-        self.base_data.page.on("dialog", lambda dialog: dialog.accept())
-
-    @async_method_callback('web', '浏览器操作', 4)
-    async def w_get_cookie(self):
-        """获取cookie"""
-        with open(os.path.join(self.base_data.download_path, 'storage_state.json'), 'w') as file:
-            file.write(json.dumps(await self.base_data.context.storage_state()))
-
-    @async_method_callback('web', '浏览器操作', 5, [
-        MethodModel(n='获取cookie方法的值', f='storage_state', p='请输入获取cookie方法中获取的内容', d=True)])
-    async def w_set_cookie(self, storage_state: str):
-        """设置cookie"""
-        if isinstance(storage_state, str):
-            storage_state = json.loads(storage_state)
-        else:
-            raise MangoAutomationError(*ERROR_MSG_0059)
-        await self.base_data.context.add_cookies(storage_state['cookies'])
-        for storage in storage_state['origins']:
-            local_storage = storage.get('localStorage', [])
-            session_storage = storage.get('sessionStorage', [])
-            for item in local_storage:
-                await self.base_data.context.add_init_script(
-                    f"window.localStorage.setItem('{item['name']}', '{item['value']}');")
-            for item in session_storage:
-                await self.base_data.context.add_init_script(
-                    f"window.sessionStorage.setItem('{item['name']}', '{item['value']}');")
-        await self.base_data.page.reload()
-
-    @async_method_callback('web', '浏览器操作', 6)
-    async def w_clear_cookies(self):
-        """清除所有cookie"""
-        await self.base_data.context.clear_cookies()
-
-    @async_method_callback('web', '浏览器操作', 7)
-    async def w_clear_storage(self):
-        """清除本地存储和会话存储"""
-        await self.base_data.page.evaluate("() => localStorage.clear()")
-        await self.base_data.page.evaluate("() => sessionStorage.clear()")

mangoautomation/uidrives/web/async_web/_customization.py

@@ -1,14 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description: # @Time   : 2023-04-26 22:22
-# @Author : 毛鹏
-
-from ..._base_data import BaseData
-from ....tools import Meta
-
-
-class AsyncWebCustomization(metaclass=Meta):
-    """定制开发"""
-
-    def __init__(self, base_data: BaseData):
-        self.base_data = base_data

mangoautomation/uidrives/web/async_web/_element.py

@@ -1,250 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description: # @Time   : 2023-04-26 22:22
-# @Author : 毛鹏
-import asyncio
-import os
-
-import time
-from playwright.async_api import Locator, Error, TimeoutError
-
-from mangotools.decorator import async_method_callback
-from mangotools.models import MethodModel
-from ..._base_data import BaseData
-from ....exceptions import MangoAutomationError
-from ....exceptions.error_msg import ERROR_MSG_0024, ERROR_MSG_0056
-from ....tools import Meta
-
-
-class AsyncWebElement(metaclass=Meta):
-    """元素操作"""
-
-    def __init__(self, base_data: BaseData):
-        self.base_data = base_data
-
-    @async_method_callback('web', '元素操作', 0, [MethodModel(f='locating')])
-    async def w_click(self, locating: Locator):
-        """元素单击"""
-        if await locating.count() < 1:
-            raise TimeoutError('元素个数小于1，直接操作超时！')
-        await locating.click()
-
-    @async_method_callback('web', '元素操作', 1, [MethodModel(f='locating')])
-    async def w_dblclick(self, locating: Locator):
-        """元素双击"""
-        if await locating.count() < 1:
-            raise TimeoutError('元素个数小于1，直接操作超时！')
-        await locating.dblclick()
-
-    @async_method_callback('web', '元素操作', 2, [MethodModel(f='locating')])
-    async def w_force_click(self, locating: Locator):
-        """强制单击"""
-        await locating.evaluate('element => element.click()')
-
-    @async_method_callback('web', '元素操作', 3, [
-        MethodModel(f='locating'),
-        MethodModel(n='输入内容', f='input_value', p='请输入输入内容', d=True)])
-    async def w_input(self, locating: Locator, input_value: str):
-        """元素输入"""
-        if await locating.count() < 1:
-            raise TimeoutError('元素个数小于1，直接操作超时！')
-        await locating.fill(str(input_value))
-
-    @async_method_callback('web', '元素操作', 4, [MethodModel(f='locating')])
-    async def w_hover(self, locating: Locator):
-        """鼠标悬停"""
-        await locating.hover()
-        await asyncio.sleep(1)
-
-    @async_method_callback('web', '元素操作', 5, [
-        MethodModel(f='locating'),
-        MethodModel(n='缓存的key', f='set_cache_key', p='请输入获取元素文本后存储的key', d=True)])
-    async def w_get_text(self, locating: Locator, set_cache_key=None):
-        """获取元素文本"""
-        if await locating.count() < 1:
-            raise TimeoutError('元素个数小于1，直接操作超时！')
-        methods = [
-            ("inner_text", locating.inner_text),
-            ("text_content", locating.text_content),
-            ("input_value", locating.input_value),
-            ("get_attribute", lambda: locating.get_attribute("value")),
-            ("evaluate", lambda: locating.evaluate("el => el.value")),
-        ]
-        for method_name, method in methods:
-            try:
-                value = await method()
-                if value is not None and str(value).strip() and set_cache_key:
-                    self.base_data.test_data.set_cache(key=set_cache_key, value=value)
-                    return value
-                elif value is not None and str(value).strip():
-                    return value
-            except Exception:
-                continue
-        return None
-
-    @async_method_callback('web', '元素操作', 5, [
-        MethodModel(f='locating'),
-        MethodModel(n='输入文本', f='input_value', p='请输入输入内容', d=True)])
-    async def w_clear_input(self, locating: Locator, input_value: str):
-        """元素清空再输入"""
-        if await locating.count() < 1:
-            raise TimeoutError('元素个数小于1，直接操作超时！')
-        await locating.clear()
-        await locating.fill(str(input_value))
-
-    @async_method_callback('web', '元素操作', 6, [MethodModel(f='locating')])
-    async def w_many_click(self, locating: Locator):
-        """多元素循环单击"""
-        await asyncio.sleep(1)
-        elements = await locating.all()
-        for element in elements:
-            await element.click()
-            await asyncio.sleep(0.2)
-
-    @async_method_callback('web', '元素操作', 6, [
-        MethodModel(f='locating'),
-        MethodModel(n='文件名称', f='file_path', p='请输入文件路径，参照帮助文档', d=True)])
-    async def w_upload_files(self, locating: Locator, file_path: str | list):
-        """拖拽文件上传"""
-        try:
-            if isinstance(file_path, str):
-                await locating.set_input_files(file_path, timeout=30000)
-            else:
-                for file in file_path:
-                    await locating.set_input_files(file, timeout=30000)
-        except Error:
-            raise MangoAutomationError(*ERROR_MSG_0024)
-
-    @async_method_callback('web', '元素操作', 7, [
-        MethodModel(f='locating'),
-        MethodModel(n='文件名称', f='file_path', p='请输入文件路径，参照帮助文档', d=True)])
-    async def w_click_upload_files(self, locating: Locator, file_path: str | list):
-        """点击并选择文件上传"""
-        async with self.base_data.page.expect_file_chooser(timeout=30000) as fc_info:
-            await locating.click()
-        file_chooser = await fc_info.value
-        await file_chooser.set_files(file_path)
-
-    @async_method_callback('web', '元素操作', 8, [
-        MethodModel(f='locating'),
-        MethodModel(n='存储key值', f='file_key', p='请输入文件存储路径的key，后续通过key获取文件保存的绝对路径', d=True)])
-    async def w_download(self, locating: Locator, file_key: str):
-        """下载文件"""
-        async with self.base_data.page.expect_download(timeout=30000) as download_info:
-            await locating.click()
-        download = await download_info.value
-        file_name = download.suggested_filename
-        save_path = os.path.join(self.base_data.download_path, file_name)
-        await download.save_as(save_path)
-        self.base_data.test_data.set_cache(file_key, file_name)
-
-    @async_method_callback('web', '元素操作', 9, [
-        MethodModel(f='locating')])
-    async def w_element_wheel(self, locating: Locator):
-        """滚动到元素位置"""
-        await locating.scroll_into_view_if_needed()
-
-    @async_method_callback('web', '元素操作', 9, [MethodModel(f='locating')])
-    async def w_right_click(self, locating: Locator):
-        """元素右键点击"""
-        await locating.click(button='right')
-
-    @async_method_callback('web', '元素操作', 10, [
-        MethodModel(f='locating'),
-        MethodModel(n='点击时间', f='n', p='请输入循环点击的时间', d=True)])
-    async def w_time_click(self, locating: Locator, n: int):
-        """循环点击N秒"""
-        try:
-            n = int(n)
-        except ValueError:
-            raise MangoAutomationError(*ERROR_MSG_0056)
-        s = time.time()
-        while True:
-            await locating.click()
-            if time.time() - s > n:
-                return
-
-    @async_method_callback('web', '元素操作', 11, [
-        MethodModel(f='locating'),
-        MethodModel(n='像素大小', f='n', p='请输入向上像素', d=True)])
-    async def w_drag_up_pixel(self, locating: Locator, n: int):
-        """往上拖动N个像素"""
-        try:
-            n = int(n)
-        except ValueError:
-            raise MangoAutomationError(*ERROR_MSG_0056)
-
-        box = await locating.bounding_box()
-
-        if box:
-            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2)
-            await self.base_data.page.mouse.down()
-            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2 - n)
-            await self.base_data.page.mouse.up()
-
-    @async_method_callback('web', '元素操作', 12, [
-        MethodModel(f='locating'),
-        MethodModel(n='像素大小', f='n', p='请输入向下像素', d=True)])
-    async def w_drag_down_pixel(self, locating: Locator, n: int):
-        """往下拖动N个像素"""
-        try:
-            n = int(n)
-        except ValueError:
-            raise MangoAutomationError(*ERROR_MSG_0056)
-
-        box = await locating.bounding_box()
-
-        if box:
-            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2)
-            await self.base_data.page.mouse.down()
-            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2 + n)
-            await self.base_data.page.mouse.up()
-
-    @async_method_callback('web', '元素操作', 13, [
-        MethodModel(f='locating'),
-        MethodModel(n='像素大小', f='n', p='请输入向左像素', d=True)])
-    async def w_drag_left_pixel(self, locating: Locator, n: int):
-        """往左拖动N个像素"""
-        try:
-            n = int(n)
-        except ValueError:
-            raise MangoAutomationError(*ERROR_MSG_0056)
-
-        box = await locating.bounding_box()
-
-        if box:
-            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2)
-            await self.base_data.page.mouse.down()
-            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2 - n, box['y'] + box['height'] / 2)
-            await self.base_data.page.mouse.up()
-
-    @async_method_callback('web', '元素操作', 14, [
-        MethodModel(f='locating'),
-        MethodModel(n='像素大小', f='n', p='请输入向右像素', d=True)])
-    async def w_drag_right_pixel(self, locating: Locator, n: int):
-        """往右拖动N个像素"""
-        try:
-            n = int(n)
-        except ValueError:
-            raise MangoAutomationError(*ERROR_MSG_0056)
-        box = await locating.bounding_box()
-
-        if box:
-            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2)
-            await self.base_data.page.mouse.down()
-            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2 + n, box['y'] + box['height'] / 2)
-            await self.base_data.page.mouse.up()
-
-    @async_method_callback('web', '元素操作', 15, [
-        MethodModel(f='locating'),
-        MethodModel(n='保存路径', f='path', p='请输入截图名称', d=True)])
-    async def w_ele_screenshot(self, locating: Locator, path: str):
-        """元素截图"""
-        await locating.screenshot(path=os.path.join(self.base_data.download_path, path))
-
-    @async_method_callback('web', '元素操作', 20, [
-        MethodModel(f='locating1'),
-        MethodModel(f='locating2')])
-    async def w_drag_to(self, locating1: Locator, locating2: Locator):
-        """拖动A元素到达B"""
-        await locating1.drag_to(locating2)

mangoautomation/uidrives/web/async_web/_input_device.py

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description: # @Time   : 2023-04-29 12:11
-# @Author : 毛鹏
-
-from mangotools.decorator import async_method_callback
-from mangotools.models import MethodModel
-from ....tools import Meta
-from ....uidrives._base_data import BaseData
-
-
-class AsyncWebDeviceInput(metaclass=Meta):
-    """输入设备"""
-
-    def __init__(self, base_data: BaseData):
-        self.base_data = base_data
-
-    @async_method_callback('web', '输入设备', 0, [
-        MethodModel(n='按键值', f='keyboard', p='请输入键盘名称，首字母大写', d=True)])
-    async def w_keys(self, keyboard: str):
-        """模拟按下指定的键"""
-        await self.base_data.page.keyboard.press(str(keyboard))
-
-    @async_method_callback('web', '输入设备', 1, [
-        MethodModel(n='滚动像素', f='y', p='请输入向上滚动像素', d=True)])
-    async def w_wheel(self, y):
-        """鼠标上下滚动像素，负数代表向上"""
-        await self.base_data.page.mouse.wheel(0, int(y))
-
-    @async_method_callback('web', '输入设备', 2, [
-        MethodModel(n='x坐标', f='x', p='请输入点击的x轴', d=True),
-        MethodModel(n='y坐标', f='y', p='请输入点击的y轴', d=True)])
-    async def w_mouse_click(self, x: float, y: float):
-        """鼠标点击坐标"""
-        await self.base_data.page.mouse.click(float(x), float(y))
-
-    @async_method_callback('web', '输入设备', 3)
-    async def w_mouse_center(self):
-        """鼠标移动到中间"""
-
-        viewport_size = await self.base_data.page.evaluate('''() => {
-            return {
-                width: window.innerWidth,
-                height: window.innerHeight
-            }
-        }''')
-        center_x = viewport_size['width'] / 2
-        center_y = viewport_size['height'] / 2
-        await self.base_data.page.mouse.move(center_x, center_y)
-
-    @async_method_callback('web', '输入设备', 4)
-    async def w_mouse_center(self):
-        """鼠标移动到中间并点击"""
-
-        viewport_size = await self.base_data.page.evaluate('''() => {
-            return {
-                width: window.innerWidth,
-                height: window.innerHeight
-            }
-        }''')
-        center_x = viewport_size['width'] / 2
-        center_y = viewport_size['height'] / 2
-        await self.base_data.page.mouse.click(center_x, center_y)
-
-    @async_method_callback('web', '输入设备', 5, [
-        MethodModel(n='输入文本', f='text', p='请输入键盘输入的内容', d=True)])
-    async def w_keyboard_type_text(self, text: str):
-        """模拟人工输入文字"""
-        await self.base_data.page.keyboard.type(str(text))
-
-    @async_method_callback('web', '输入设备', 6, [
-        MethodModel(n='输入文本', f='text', p='请输入键盘输入的内容', d=True)])
-    async def w_keyboard_insert_text(self, text: str):
-        """直接输入文字"""
-        await self.base_data.page.keyboard.insert_text(str(text))
-
-    @async_method_callback('web', '输入设备', 7, [
-        MethodModel(n='删除个数', f='count', p='请输入要删除字符串的个数', d=True)])
-    async def w_keyboard_delete_text(self, count: int):
-        """删除光标左侧的字符"""
-        for _ in range(0, int(count) + 1):
-            await self.base_data.page.keyboard.press("Backspace")

mangoautomation/uidrives/web/async_web/_new_browser.py

@@ -1,153 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description:
-# @Time   : 2024-04-24 10:43
-# @Author : 毛鹏
-import asyncio
-import ctypes
-import os
-import string
-import traceback
-from typing import Optional
-
-from playwright._impl._errors import Error
-from playwright.async_api import async_playwright, Page, BrowserContext, Browser, Playwright, Request, Route
-
-from ....enums import BrowserTypeEnum
-from ....exceptions import MangoAutomationError
-from ....exceptions.error_msg import ERROR_MSG_0057, ERROR_MSG_0008, ERROR_MSG_0062, ERROR_MSG_0009, ERROR_MSG_0055
-
-"""
-python -m uiautomator2 init
-python -m weditor
-
-"""
-
-
-class AsyncWebNewBrowser:
-
-    def __init__(self,
-                 web_type: int,
-                 web_path: str | None = None,
-                 web_max=False,
-                 web_headers=False,
-                 web_recording=False,
-                 web_h5=None,
-                 is_header_intercept=False,
-                 web_is_default=False,
-                 videos_path=None,
-                 log=None,
-                 ):
-        self.lock = asyncio.Lock()
-        self.web_type = web_type
-        self.web_path = web_path
-        self.web_max = web_max
-        self.web_headers = web_headers
-        self.web_recording = web_recording
-        self.web_h5 = web_h5
-        self.web_is_default = web_is_default
-        self.is_header_intercept = is_header_intercept
-        self.videos_path = videos_path
-        self.log = log
-        self.browser_path = ['chrome.exe', 'msedge.exe', 'firefox.exe', '苹果', '360se.exe']
-        self.browser: Optional[None | Browser] = None
-        self.playwright: Optional[None | Playwright] = None
-
-    async def new_web_page(self, count=0) -> tuple[BrowserContext, Page]:
-        if self.browser is None:
-            async with self.lock:
-                if self.browser is None:
-                    self.browser = await self.new_browser()
-                    await asyncio.sleep(1)
-        try:
-            context = await self.new_context()
-            page = await self.new_page(context)
-            return context, page
-        except Exception:
-            self.log.error(f'初始化page失败，错误信息：{traceback.format_exc()}')
-            self.browser = None
-            if count >= 3:
-                raise MangoAutomationError(*ERROR_MSG_0057)
-            else:
-                return await self.new_web_page(count=count + 1)
-
-    async def new_browser(self) -> Browser:
-        self.playwright = await async_playwright().start()
-        if self.web_type == BrowserTypeEnum.CHROMIUM.value or self.web_type == BrowserTypeEnum.EDGE.value:
-            browser = self.playwright.chromium
-        elif self.web_type == BrowserTypeEnum.FIREFOX.value:
-            browser = self.playwright.firefox
-        elif self.web_type == BrowserTypeEnum.WEBKIT.value:
-            browser = self.playwright.webkit
-        else:
-            raise MangoAutomationError(*ERROR_MSG_0008)
-        if self.web_is_default:
-            try:
-                return await browser.launch()
-            except Error as error:
-                self.log.error(f'初始化浏览器失败-1，类型：{error}，详情：{traceback.format_exc()}')
-                raise MangoAutomationError(*ERROR_MSG_0062)
-        else:
-            try:
-                if self.web_max:
-                    return await browser.launch(
-                        headless=self.web_headers,
-                        executable_path=self.web_path if self.web_path else self.__search_path(),
-                        args=['--start-maximized']
-                    )
-                else:
-                    return await browser.launch(
-                        headless=self.web_headers,
-                        executable_path=self.web_path if self.web_path else self.__search_path()
-                    )
-            except Error as error:
-                self.log.error(f'初始化浏览器失败-2，类型：{error}，详情：{traceback.format_exc()}')
-                raise MangoAutomationError(*ERROR_MSG_0009, value=(self.web_path,))
-
-    async def new_context(self) -> BrowserContext:
-        args_dict = {'ignore_https_errors': True}
-        if self.web_is_default:
-            args_dict["viewport"] = {"width": 1920, "height": 1080}
-        if self.web_h5:
-            args_dict.update(self.playwright.devices[self.web_h5])
-        if not (self.web_is_default or self.web_h5):
-            args_dict["no_viewport"] = True
-        if self.web_recording and self.videos_path:
-            args_dict["record_video_dir"] = self.videos_path
-        context = await self.browser.new_context(**args_dict)
-        context.set_default_timeout(3000)
-        return context
-
-    async def new_page(self, context: BrowserContext) -> Page:
-        try:
-            page = await context.new_page()
-            page.set_default_timeout(3000)
-            if self.is_header_intercept:
-                await page.route("**/*", self.wen_intercept_request)  # 应用拦截函数到页面的所有请求
-            return page
-        except Error as error:
-            self.log.error(f'初始化page失败，类型：{error}，详情：{traceback.format_exc()}')
-            raise MangoAutomationError(*ERROR_MSG_0009, value=(self.web_path,))
-
-    async def close(self):
-        if self.browser:
-            await self.browser.close()
-
-    def __search_path(self, ):
-        drives = []
-        for letter in string.ascii_uppercase:
-            drive = f"{letter}:\\"
-            if ctypes.windll.kernel32.GetDriveTypeW(drive) == 3:
-                drives.append(drive)
-        for i in drives:
-            for root, dirs, files in os.walk(i):
-                if self.browser_path[self.web_type] in files:
-                    return os.path.join(root, self.browser_path[self.web_type])
-
-        raise MangoAutomationError(*ERROR_MSG_0055)
-
-    async def wen_intercept_request(self, route: Route, request: Request):
-        pass
-
-    async def wen_recording_api(self, request: Request, project_product: int):
-        pass

mangoautomation/uidrives/web/async_web/_page.py

@@ -1,63 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description: # @Time   : 2023-04-25 22:33
-# @Author : 毛鹏
-import asyncio
-
-from playwright.async_api import Locator
-
-from mangotools.decorator import async_method_callback
-from mangotools.models import MethodModel
-from ....tools import Meta
-from ....uidrives._base_data import BaseData
-
-
-class AsyncWebPage(metaclass=Meta):
-    """页面操作"""
-
-    def __init__(self, base_data: BaseData):
-        self.base_data = base_data
-
-    @async_method_callback('web', '页面操作', 0, [
-        MethodModel(n='页签下标', f='individual', p='请输入页签下标，从1开始数', d=True)])
-    async def w_switch_tabs(self, individual: int):
-        """切换页签"""
-        pages = self.base_data.context.pages
-        await pages[int(individual) + 1].bring_to_front()
-        self.base_data.page = pages[int(individual) + 1]
-        await asyncio.sleep(1)
-
-    @async_method_callback('web', '页面操作', 1)
-    async def w_close_current_tab(self):
-        """关闭当前页签"""
-        await asyncio.sleep(2)
-        pages = self.base_data.context.pages
-        await pages[-1].close()
-        self.base_data.page = pages[0]
-
-    @async_method_callback('web', '页面操作', 2, [MethodModel(f='locating')])
-    async def w_open_new_tab_and_switch(self, locating: Locator):
-        """点击并打开新页签"""
-
-        await locating.click()
-        await asyncio.sleep(2)
-        pages = self.base_data.context.pages
-        new_page = pages[-1]
-        await new_page.bring_to_front()
-        self.base_data.page = new_page
-        await asyncio.sleep(1)
-
-    @async_method_callback('web', '页面操作', 3)
-    async def w_refresh(self):
-        """刷新页面"""
-        await self.base_data.page.reload()
-
-    @async_method_callback('web', '页面操作', 4)
-    async def w_go_back(self):
-        """返回上一页"""
-        await self.base_data.page.go_back()
-
-    @async_method_callback('web', '页面操作', 5)
-    async def w_go_forward(self):
-        """前进到下一页"""
-        await self.base_data.page.go_forward()