python-qlv-helper 0.5.7__py3-none-any.whl → 0.7.2__py3-none-any.whl

qlv_helper/po/login_page.py

@@ -11,8 +11,7 @@
 """
 from typing import Tuple, Union
 from playwright_helper.libs.base_po import BasePo
-from qlv_helper.utils.ocr_helper import get_image_text
-from playwright.async_api import Page, TimeoutError as PlaywrightTimeoutError, Locator
+from playwright.async_api import Page, TimeoutError as PlaywrightTimeoutError, Locator, ElementHandle
 
 
 class LoginPage(BasePo):
@@ -22,104 +21,67 @@ class LoginPage(BasePo):
         super().__init__(page, url)
         self.__page = page
 
-    async def get_login_username_input(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_login_username_input(self, timeout: float = 5.0) -> Locator:
         """
         获取登录页面的用户名输入框
         :param timeout: 超时时间（秒）
         :return: (是否存在, 错误信息|元素对象)
-        :return:
         """
         selector: str = '//input[@id="UserName"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到登录页面中的【用户名】输入框'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_login_password_input(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_login_password_input(self, timeout: float = 5.0) -> Locator:
         """
         获取登录页面的密码输入框
         :param timeout: 超时时间（秒）
         :return: (是否存在, 错误信息|元素对象)
-        :return:
         """
         selector: str = '//input[@id="Password"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到登录页面中的【密码】输入框'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_login_number_code_input(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_captcha(self, timeout: float = 5.0) -> Locator:
         """
-        获取登录页面的数字验证码输入框，第一层验证码
+        获取验证码Locator对象
         :param timeout: 超时时间（秒）
         :return: (是否存在, 错误信息|元素对象)
-        :return:
         """
-        selector: str = '//input[@id="Code"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到登录页面中的【数字验证码】输入框'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        selector: str = 'xpath=//div[@class="form_row"]/img[@onclick="this.src=this.src+\'?\'"]'
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_login_btn(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    @staticmethod
+    async def get_captcha_type(locator: Locator, timeout: float = 5.0) -> int:
         """
-        获取登录页面的登录按钮
+        获取验证码的类型
+        :param locator: 验证码Locator对象
         :param timeout: 超时时间（秒）
         :return: (是否存在, 错误信息|元素对象)
-        :return:
         """
-        selector: str = '//input[@class="login-btn"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到登录页面中的【登录】按钮'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        img_src: str = await locator.get_attribute(name="src", timeout=timeout)
+        img_src_slice = img_src.split("=")
+        return int(img_src_slice[-1][0])
 
-    async def get_number_code(self, timeout: float = 5.0) -> Tuple[bool, str]:
+    async def get_captcha_image(self, timeout: float = 5.0) -> ElementHandle:
         selector: str = '//div[@id="signup_forms"]//img'
-        return await get_image_text(page=self.__page, selector=selector, timeout=timeout)
+        locator: Locator = await self.get_locator(selector=selector, timeout=timeout)
+        return await locator.element_handle(timeout=timeout * 1000)
 
-    async def is_exist_login_warn(self, timeout: float = 5.0) -> bool:
-        selector: str = '//p[@class="login_warn"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                text: str = await locator.text_content(timeout=timeout * 1000)
-                if text.strip() != "":
-                    return True
-                else:
-                    return False
-            else:
-                return False
-        except (PlaywrightTimeoutError, Exception):
-            return False
+    async def get_login_captcha_input(self, timeout: float = 5.0) -> Locator:
+        """
+        获取登录页面的验证码输入框
+        :param timeout: 超时时间（秒）
+        :return: (是否存在, 错误信息|元素对象)
+        """
+        selector: str = '//input[@id="Code"]'
+        return await self.get_locator(selector=selector, timeout=timeout)
+
+    async def get_login_btn(self, timeout: float = 5.0) -> Locator:
+        """
+        获取登录页面的登录按钮
+        :param timeout: 超时时间（秒）
+        :return: (是否存在, 错误信息|元素对象)
+        """
+        selector: str = '//input[@class="login-btn"]'
+        return await self.get_locator(selector=selector, timeout=timeout)
 
     async def get_wechat_entrance(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
         selector: str = '//img[@src="/images/weixin.png"]'

qlv_helper/po/main_page.py

@@ -9,9 +9,8 @@
 # Copyright ©2011-2025. Hunan xxxxxxx Company limited. All rights reserved.
 # ---------------------------------------------------------------------------------------------------------
 """
-from typing import Tuple, Union
+from playwright.async_api import Page, Locator
 from playwright_helper.libs.base_po import BasePo
-from playwright.async_api import Page, TimeoutError as PlaywrightTimeoutError, Locator
 
 
 class MainPage(BasePo):
@@ -23,48 +22,18 @@ class MainPage(BasePo):
         self.url = url
         self.__page = page
 
-    async def get_confirm_btn_with_system_notice_dialog(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_confirm_btn_with_system_notice_dialog(self, timeout: float = 5.0) -> Locator:
         """
         获取系统通知弹框中的确认按钮，注意这个地方，存在多个叠加的弹框，因此用last()方法，只需定位到最上面的那个弹框就行
         :return:
         """
         selector: str = "//div[@class='CommonAlert'][last()]//a[@class='CommonAlertBtnConfirm']"
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到首页中的【系统提醒-确定】按钮'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_level1_menu_order_checkout(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_level1_menu_order_checkout(self, timeout: float = 5.0) -> Locator:
         selector: str = "//span[contains(normalize-space(), '订单出票')]"
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到首页中的【订单出票】左侧一级导航菜单'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_level2_menu_order_checkout(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_level2_menu_order_checkout(self, timeout: float = 5.0) -> Locator:
         selector: str = "//a[@menuname='国内活动订单']"
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到首页中的【国内活动订单】左侧二级导航菜单'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)

qlv_helper/po/order_detail_page.py

@@ -273,3 +273,20 @@ class OrderDetailPage(BasePo):
         """
         selector: str = '//legend//input[@name="PolicyName"]'
         return await self.get_locator(selector=selector, timeout=timeout)
+
+    async def get_purchase_info_transaction_id(self, timeout: float = 5.0) -> List[str]:
+        """
+        获取订单详情页面的采购信息流水
+        :param timeout:
+        :return:
+        """
+        # selector: str = '//tr[@class="PurchaseInfoClass"]'
+        selector: str = '//table[@id="PurchaseInfos"]/tbody/tr'
+        loc: Locator = await self.get_locator(selector=selector, timeout=timeout)
+        locators = await loc.all()
+        transaction_ids = list()
+        for locator in locators:
+            transaction_id = await locator.get_attribute("transactionid")
+            if transaction_id:
+                transaction_ids.append(transaction_id.strip())
+        return transaction_ids

qlv_helper/utils/ocr_helper.py

@@ -9,11 +9,13 @@
 # Copyright ©2011-2025. Hunan xxxxxxx Company limited. All rights reserved.
 # ---------------------------------------------------------------------------------------------------------
 """
+import json
+import asyncio
 import ddddocr
 import requests
-from typing import Union, Tuple
+from typing import Tuple
 from aiohttp import ClientSession
-from playwright.async_api import Page, TimeoutError as PlaywrightTimeoutError
+from ocr_helper.core.baidu import ImageContentOCR
 
 # 复用 OCR 实例，不用每次都重新加载模型（更快）
 _ocr = ddddocr.DdddOcr(show_ad=False)
@@ -39,45 +41,38 @@ async def async_fetch_and_ocr_captcha(url: str) -> Tuple[str, bytes]:
     return result, img_bytes
 
 
-def recognize_captcha(image: Union[str, bytes]) -> str:
-    """
-    识别验证码图片，返回识别文本。
-    参数:
-        image: 图片路径 str，或图片的二进制 bytes
-    返回:
-        识别出的验证码字符串
-    """
-    try:
-        # 如果是路径，读取文件
-        if isinstance(image, str):
-            with open(image, "rb") as f:
-                img_bytes = f.read()
+async def get_image_text(image_path: str, captcha_type: int, api_key, secret_key: str) -> str:
+    if captcha_type == 0:
+        with open(image_path, "rb") as f:
+            img_bytes = f.read()
+        for _ in range(100):
+            text = _ocr.classification(img_bytes).strip()
+            if len(text) == 4:
+                return text
+        raise RuntimeError("ddddocr识别验证码失败")
+    else:
+        api = ImageContentOCR(api_key=api_key, secret_key=secret_key)
+        response = await api.get_access_token(is_end=False)
+        if not response.get("access_token"):
+            raise RuntimeError(f"获取百度API的认证Token失败，原因：{response}")
+        token = response.get("access_token")
+        response = await api.submit_request(
+            question='图片中的文字是什么，如果含有运算信息，请将运算结果返回。注意给我返回一个json格式数据包，例如：{"content":"xxxx", result: xxx}, 如果无运算信息，设置为空串就行',
+            image_path=image_path,
+            token=token,
+            is_end=False
+        )
+        task_id: str = response.get("result", dict()).get("task_id")
+        if not task_id:
+            raise RuntimeError(f"提交图片至百度API接口失败，原因：{response}")
+        await asyncio.sleep(delay=10)
+        response = await api.get_result(task_id=task_id, token=token, is_end=True)
+        if response.get("result").get("ret_code") == 0 and response.get("result").get("ret_msg") == "success":
+            description = response.get("result").get("description")
+            description = json.loads(description[description.find("{"):description.find("}") + 1])
+            if description.get("result"):
+                return str(description.get("result")).strip()
+            else:
+                return description.get("content").strip()
         else:
-            img_bytes = image
-
-        result = _ocr.classification(img_bytes)
-        return result
-
-    except Exception as e:
-        raise RuntimeError(f"OCR 识别失败: {e}")
-
-
-async def get_image_text(page: Page, selector: str, timeout: float = 5.0) -> Tuple[bool, str]:
-    try:
-        # 找到 img
-        locator = page.locator(selector)
-        if locator:
-            img = await locator.element_handle(timeout=timeout * 1000)
-
-            # 直接截图获取原始图片字节，不刷新图片
-            img_bytes = await img.screenshot(timeout=timeout * 1000)
-
-            # OCR 识别
-            text = _ocr.classification(img_bytes)
-            return True, text.strip()
-        else:
-            return False, f'没有找到当前页面中的【{selector}】图片'
-    except PlaywrightTimeoutError:
-        return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-    except Exception as e:
-        return False, f"检查元素时发生错误: {str(e)}"
+            raise RuntimeError(f"调用百度API，获取图片识别结果失败，原因{response}")