refactor(预定系统): 重构测试用例的路径设置和模块导入

- 新增兼容 PyInstaller 打包后的路径设置
- 优化 sys.path 的设置，确保 Base 目录始终在最前
- 更新模块导入方式，使用相对路径导入 base 模块- 删除重复的代码块和不必要的注释

预定系统/Base/base.py

@@ -186,8 +186,8 @@ def get_login_url_from_config(login_type):
 
     # 获取当前脚本的绝对路径
     current_dir = os.path.dirname(os.path.abspath(__file__))
-    # 构建配置文件的绝对路径，指向 ubains-module-test 目录下的 config.json
-    config_path = os.path.abspath(os.path.join(current_dir, '..', '..', 'config.json'))
+    # 构建配置文件的绝对路径，指向与 Base 同级的 config.json
+    config_path = os.path.join(os.path.dirname(current_dir), 'config.json')
     # 规范化路径，防止路径遍历攻击
     config_path = os.path.normpath(config_path)
 
@@ -220,6 +220,8 @@ def get_login_url_from_config(login_type):
         # 如果未找到对应的 URL，则抛出异常
         raise ValueError(f"未找到对应的 URL 配置项: {login_type}")
 
+    print("正在打开登录页面：" + login_url)
+
     # 返回登录 URL
     return login_url
 

预定系统/cases/AI创会/AI创会.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/AI创会/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/__st__.py

 import sys
 import os
-# 获取当前脚本的绝对路径
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', 'Base'))
+if base_dir not in sys.path:
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+
+def suite_teardown():
+    browser_quit()
 
 # def suite_setup():
 #     STEP(1, "初始化浏览器")
 #     browser_init()
 #     # STEP(2, "处理SSL认证")
-#     # handle_ssl_warning()
-
+#     # handle_ssl_warning()
\ No newline at end of file
-def suite_teardown():
-    browser_quit()
\ No newline at end of file

预定系统/cases/会控-SMC/SMC会控.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会控-SMC/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会控-腾讯会议/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会控-腾讯会议/腾讯会控.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议主流程/01会议预约/01会议预约.py

-from datetime import datetime, timedelta
-from time import sleep
 import sys
 import os
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议主流程/01会议预约/JSON测试.py

-import sys
-import os
-import openpyxl
-import json
-from 预定系统.Base.base import INFO
-
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
-
-# 获取当前脚本所在的目录
-current_dir = os.path.dirname(os.path.abspath(__file__))
-
-# 构建CSV文件的绝对路径
-csv_file_path = os.path.join(current_dir, '../../../测试数据/登录模块/新账号密码登录.xlsx')
-
-def read_xlsx_data(xlsx_file_path):
-    """
-    读取XLSX文件中的数据，并将其转换为一个包含字典的列表，每个字典代表一行测试用例数据。
-
-    参数:
-    xlsx_file_path (str): XLSX文件的路径。
-
-    返回:
-    list: 包含字典的列表，每个字典包含测试用例的名称和参数。
-    """
-    # 打开XLSX文件
-    workbook = openpyxl.load_workbook(xlsx_file_path)
-    # 假设数据在第一个工作表中
-    sheet = workbook.active
-
-    # 读取表头，从第三行开始
-    headers = [cell.value for cell in sheet[3]]
-
-    # 打印表头列名
-    # print(f"表头列名: {headers}")
-
-    # 找到表头中名为 'JSON' 的列索引
-    try:
-        json_index = headers.index('JSON')
-    except ValueError as e:
-        raise ValueError(f"表头中没有找到所需的列: {e}")
-
-    ddt_cases = []
-    # 遍历XLSX文件中的每一行数据，从第四行开始
-    for row in sheet.iter_rows(min_row=4, values_only=True):
-        # 获取 JSON 列的数据
-        json_data = row[json_index]
-
-        # 打印 JSON 数据以进行调试
-        # print(f"JSON 数据: {json_data}")
-
-        # 解析 JSON 字符串
-        try:
-            if json_data:
-                parsed_json = json.loads(json_data)
-            else:
-                raise ValueError("JSON 数据为空")
-        except json.JSONDecodeError:
-            raise ValueError(f"无法解析 JSON 数据: {json_data}")
-
-        # 将解析后的 JSON 数据添加到列表中
-        ddt_cases.append(parsed_json)
-
-    # 日志记录：XLSX文件已读取
-    INFO("XLSX文件已读取")
-    # 返回包含所有测试用例数据的列表
-    return ddt_cases
-
-
-if __name__ == '__main__':
-    ddt_cases = read_xlsx_data(csv_file_path)
-    # print(ddt_cases)
-    browser_init("标准版预定系统")
-    wd = GSTORE['wd']
-
-    # 遍历 ddt_cases 并获取每一个 JSON 对象
-    for case in ddt_cases:
-        for step in case:
-            print(f"当前步骤: {step}")
-            # 你可以在这里对 step 进行进一步处理
-            # 例如：访问特定字段
-            # page = step.get('page')
-            # 调用get_by_enum将定位类型转为枚举
-            locator_type = get_by_enum(step.get('locator_type'))
-            locator_value = step.get('locator_value')
-            element_type = step.get('element_type')
-            element_value = step.get('element_value')
-            #
-            # print(f"页面: {page}")
-            # print(f"元素定位类型: {locator_type}")
-            # print(f"元素定位值: {locator_value}")
-            # print(f"元素类型: {element_type}")
-            # print(f"输入值: {element_value}")
-
-            safe_send_keys((locator_type, locator_value), element_value, wd)
-            sleep(5)
\ No newline at end of file

预定系统/cases/会议主流程/01会议预约/__st__.py

 import sys
 import os
-from time import sleep
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议主流程/02会议修改/02会议修改.py

-from datetime import  timedelta
 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
+
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议主流程/02会议修改/__st__.py

 import sys
 import os
-from time import sleep
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议主流程/03会议删除/03会议删除.py

-from datetime import  timedelta
 import sys
 import os
+from hytest import *
 
-from pkg_resources import safe_listdir
-
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议主流程/03会议删除/__st__.py

 import sys
 import os
-from time import sleep
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议主流程/04会议状态设置/04会议状态设置.py

 import sys
 import os
-from time import sleep
-from datetime import timedelta
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议主流程/04会议状态设置/__st__.py

 import sys
 import os
-from time import sleep
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议修改/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议修改/会议修改.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议创建/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议创建/会议创建.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议历史记录-旧/01历史记录筛选.py

-from datetime import datetime, timedelta
-from time import sleep
+import sys
 import sys
 import os
 
-from selenium.webdriver.support.expected_conditions import element_to_be_clickable
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议历史记录-旧/02历史记录再次预定.py

-from datetime import datetime, timedelta
-from time import sleep
+import sys
 import sys
 import os
 
-from selenium.webdriver.support.expected_conditions import element_to_be_clickable
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议历史记录-旧/__st__.py

 import sys
 import os
-from time import sleep
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议历史记录/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议历史记录/会议历史记录.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议审批/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议审批/会议审批.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议审批旧/01审批会议创建.py

-from datetime import datetime, timedelta
-from time import sleep
 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议审批旧/02审批会议操作.py

-import logging
-from datetime import datetime, timedelta
-from time import sleep
 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议审批旧/__st__.py

 import sys
 import os
-from time import sleep
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议室列表/__st__.py

 import sys
 import os
-from time import sleep
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议室列表/会议室列表功能测试.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议室管理/会议室管理.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/会议室管理/01会议室新增.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/会议室管理/02会议室查询.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/会议室管理/03会议室删除.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/会议室管理/04会议室编辑.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/会议室管理/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议室管理旧/功能管理/01功能新增.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/功能管理/02功能删除.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/功能管理/03功能查询.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/功能管理/04功能编辑.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/功能管理/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议室管理旧/区域管理/01区域新增.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/区域管理/02区域删除.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/区域管理/03区域编辑.py

-from time import sleep
-from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议室管理旧/区域管理/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议模板-旧/01会议模板查询.py

 import sys
 import os
 
-from selenium.webdriver.support.expected_conditions import element_to_be_clickable
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议模板-旧/02会议模板再次预定.py

-from datetime import datetime, timedelta
-from time import sleep
 import sys
 import os
 
-from selenium.webdriver.support.expected_conditions import element_to_be_clickable
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/会议模板-旧/__st__.py

 import sys
 import os
-from time import sleep
-# 获取当前脚本的绝对路径
+from hytest import *
+
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议模板/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/会议模板/会议模板.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/信息发布/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/信息发布/信息发布.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/信息统计/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/信息统计/信息统计.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/全局配置/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/全局配置/全局配置.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/安卓信息/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/安卓信息/安卓信息.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/展厅巡检/00服务器监测/01服务器状态监测.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 
 class Server_monitoring_0001:

预定系统/cases/展厅巡检/00服务器监测/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/展厅巡检/01展厅中控屏/__st__.py

 import sys
 import os
-from venv import logger
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
+    from base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
 
 def suite_setup():
     STEP(1, "初始化设备adb连接")

预定系统/cases/展厅巡检/01展厅中控屏/展厅中控屏.py

-from 预定系统.Base.app_base import *
 import logging
 from time import sleep
 from hytest import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
 
 # 配置日志记录
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

预定系统/cases/展厅巡检/02预定系统巡检/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/展厅巡检/02预定系统巡检/展厅会议预约巡检.py

-from datetime import  timedelta
 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/展厅巡检/02预定系统巡检/讯飞转录流程测试.py

-from datetime import  timedelta
 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/展厅巡检/03无纸化/01无纸化1.0同屏测试.py

-from 预定系统.Base.app_base import *
-import logging
-import time
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
 
 class same_screen_share_000x:
     """

预定系统/cases/展厅巡检/03无纸化/01无纸化2.0同屏巡检.py

-from 预定系统.Base.app_base import *
-import logging
-import time
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
 
 class SameScreenShare:
     """

预定系统/cases/展厅巡检/03无纸化/02无纸化1.0.py

 from appium.webdriver.common.appiumby import AppiumBy
-from 预定系统.Base.app_base import *
 import logging
 from time import sleep
 from hytest import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
+
+
 
 # 配置日志记录
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

预定系统/cases/展厅巡检/03无纸化/02无纸化2.0.py

 from appium.webdriver.common.appiumby import AppiumBy
-from 预定系统.Base.app_base import *
 import logging
 from time import sleep
 from hytest import *
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
 
 # 配置日志记录
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

预定系统/cases/展厅巡检/03无纸化/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
 
 def suite_setup():
     STEP(1, "初始化设备1的adb连接")

预定系统/cases/展厅巡检/04软终端入会/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/展厅巡检/04软终端入会/移动端入会.py

 from appium.webdriver.common.appiumby import AppiumBy
-from 预定系统.Base.app_base import *
 import logging
 from time import sleep
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
+
 
 # 配置日志记录
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

预定系统/cases/展厅巡检/05展厅会议室中控屏/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
 
 def suite_setup():
     STEP(1, "初始化设备adb连接")

预定系统/cases/展厅巡检/05展厅会议室中控屏/展厅会议室中控屏.py

-from 预定系统.Base.app_base import *
-from 预定系统.Base.base import *
 import logging
 from time import sleep
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
+from base import *
+
 
 # 配置日志记录
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

预定系统/cases/展厅巡检/06讯飞系统巡检/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/展厅巡检/06讯飞系统巡检/讯飞系统巡检.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
+from base import *
 
 class XFMeeting:
     tags = ['展厅巡检','讯飞测试','展厅讯飞转录流程测试']

预定系统/cases/展厅巡检/07运维系统/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/展厅巡检/07运维系统/运维系统巡检.py

 import sys
 import os
-
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 class Operation_maintenance_0001:
     tags = ['展厅巡检','运维系统巡检']

预定系统/cases/展厅巡检/08统一平台系统/01统一平台巡检.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 class UnifiedPlatform:
     tags = ['展厅巡检','统一平台系统巡检']

预定系统/cases/展厅巡检/08统一平台系统/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/展厅巡检/09统一平台腾讯终端入会/01软终端入会.py

 import sys
 import os
 from appium.webdriver.common.appiumby import AppiumBy
-from 预定系统.Base.app_base import *
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
+from base import *
 
 class UnifiedPlatformTerminal:
     tags = ['统一平台终端入会']

预定系统/cases/展厅巡检/09统一平台腾讯终端入会/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/展厅巡检/10桌牌系统/__st__.py

 import sys
 import os
-from time import sleep
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/展厅巡检/10桌牌系统/桌牌系统巡检.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
+from base import *
 
 class MeetingTableCard:
     tags = ['展厅巡检','桌牌测试']

预定系统/cases/展厅巡检/11环境清除/01展厅会议室中控屏.py

-from 预定系统.Base.app_base import *
-from 预定系统.Base.base import *
 import logging
 from time import sleep
+import sys
+import os
+
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from app_base import *
+from base import *
+
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/展厅巡检/11环境清除/__st__.py

 import sys
 import os
-from venv import logger
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
 try:
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
+    from base import *
+    from app_base import *
 except ModuleNotFoundError as e:
     print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
-    from 预定系统.Base.app_base import *
 
 def suite_setup():
     STEP(1, "初始化设备adb连接")

预定系统/cases/展厅巡检/test.py

-from 预定系统.Base.base import fetch_and_parse_check_txt
-
-if __name__ == "__main__":
-    # 使用示例
-    # url = "https://192.168.5.218:8443/media/file/check.txt"
-    # save_directory = r"D:\GithubData\自动化\ubains-module-test\预定系统\reports"  # 指定保存目录
-    # filename = "check.txt"
-    # download_file(url, save_directory, filename)
-
-    # 使用示例
-    url = "https://192.168.5.218:8443/media/file/check.txt"
-    save_path = "check.txt"
-    extract_info = ['[m]ysql', '[r]edis', '[f]dfs_storaged', '[f]dfs_tracker', '[e]mqx',
-                    'ubains-meeting-api-1.0-SNAPSHOT.jar', 'ubains-meeting-inner-api-1.0-SNAPSHOT.jar', 'uwsgi']
-
-    info = fetch_and_parse_check_txt(url, save_path, extract_info)
-    if info:
-        for key, value in info.items():
-            print(f"{key} 服务的状态是 {value}")
-    else:
-        print("无法获取或解析文件内容")
\ No newline at end of file

预定系统/cases/授权码管理/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/授权码管理/授权码管理.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/登录模块/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 def suite_setup():
     STEP(1, "初始化浏览器")

预定系统/cases/登录模块/新-账号密码登录测试.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/登录模块/账号密码登录测试.py

 from time import sleep
 import sys
 import os
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.base import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 DEFAULT_WAIT_TIME = 20
 # 默认等待时间（秒），用于元素加载或操作之间的等待

预定系统/cases/系统管理/__st__.py

 import sys
 import os
+from hytest import *
 
-# 获取当前脚本的绝对路径
+# 获取 Base 目录的绝对路径，并加入 sys.path
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+base_dir = os.path.abspath(os.path.join(current_dir, '..', '..', 'Base'))
+if base_dir not in sys.path:
+    print(f"Adding Base directory to sys.path: {base_dir}")
+    sys.path.insert(0, base_dir)
+
+try:
+    from base import *
+except ModuleNotFoundError as e:
+    print(f"ModuleNotFoundError: {e}")
 
 
 def suite_setup():

预定系统/cases/系统管理/系统设置.py

 import sys
 import os
 
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-from 预定系统.Base.base import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from base import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/设备管理/安卓信息.py

 from hytest import *
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.Mqtt_Send import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.Mqtt_Send import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from Mqtt_Send import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))

预定系统/cases/设备管理/毫米波雷达.py

 import sys
 import os
-# 获取当前脚本的绝对路径
-current_dir = os.path.dirname(os.path.abspath(__file__))
-# 构建预定系统的绝对路径
-预定系统_path = os.path.abspath(os.path.join(current_dir, '..','..','..'))
-# 添加路径
-sys.path.append(预定系统_path)
-# 导入模块
-try:
-    from 预定系统.Base.Mqtt_Send import *
-except ModuleNotFoundError as e:
-    print(f"ModuleNotFoundError: {e}")
-    print("尝试使用绝对路径导入")
-    from 预定系统.Base.Mqtt_Send import *
+# 兼容 PyInstaller 打包后的路径
+if hasattr(sys, '_MEIPASS'):
+    base_path = sys._MEIPASS
+else:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+
+base_path = os.path.abspath(base_path)
+base_base_path = os.path.join(base_path, 'Base')
+if base_base_path not in sys.path:
+    sys.path.insert(0, base_base_path)
+
+from Mqtt_Send import *
 
 # 获取当前脚本所在的目录
 current_dir = os.path.dirname(os.path.abspath(__file__))