Initial commit

unilabos/devices/platereader/NivoDriver.py

@@ -0,0 +1,295 @@
+import time
+import traceback
+from typing import Optional
+
+import requests
+from pywinauto.application import WindowSpecification
+from pywinauto.controls.uiawrapper import UIAWrapper
+from pywinauto_recorder import UIApplication
+from pywinauto_recorder.player import UIPath, click, focus_on_application, exists, find, FailedSearch
+
+from unilabos.device_comms import universal_driver as ud
+from unilabos.device_comms.universal_driver import UniversalDriver, SingleRunningExecutor
+from unilabos.utils.pywinauto_util import connect_application, get_process_pid_by_name, \
+    get_ui_path_with_window_specification
+
+
+class NivoDriver(UniversalDriver):
+    # 初始指定
+    _device_ip: str = None
+    # 软件状态检测
+    _software_enabled: bool = False
+    _software_pid: int = None
+    _http_service_available: bool = False
+
+    # 初始化状态
+    _is_initialized: bool = False
+
+    # 任务是否成功
+    _success: bool = False
+
+    # 运行状态
+    _is_executing_run: bool = False
+    _executing_ui_path: Optional[UIPath] = None
+    _executing_index: Optional[int] = None
+    _executing_status: Optional[str] = None
+    _total_tasks: Optional[list[str]] = None
+    _guide_app: Optional[UIApplication] = None
+
+    @property
+    def executing_status(self) -> str:
+        if self._total_tasks is None:
+            return f"无任务"
+        if self._executing_index is None:
+            return f"等待任务开始，总计{len(self._total_tasks)}个".encode('utf-8').decode('utf-8')
+        else:
+            return f"正在执行第{self._executing_index + 1}/{len(self._total_tasks)}个任务，当前状态：{self._executing_status}".encode('utf-8').decode('utf-8')
+
+    @property
+    def device_ip(self) -> str:
+        return self._device_ip
+
+    @property
+    def success(self) -> bool:
+        return self._success
+
+    @property
+    def status(self) -> str:
+        return f"Software: {self._software_enabled}, HTTP: {self._http_service_available} Initialized: {self._is_initialized} Executing: {self._is_executing_run}"
+
+    def set_device_addr(self, device_ip_str):
+        self._device_ip = device_ip_str
+        print(f"Set device IP to: {self.device_ip}")
+
+    def run_instrument(self):
+        if not self._is_initialized:
+            print("Instrument is not initialized")
+            self._success = False
+            return False
+        def post_func(res, _):
+            self._success = res
+            if not res:
+                self._is_executing_run = False
+        ins: SingleRunningExecutor = SingleRunningExecutor.get_instance(self.execute_run_instrument, post_func)
+        if not ins.is_ended and ins.is_started:
+            print("Function is running")
+            self._success = False
+            return False
+        elif not ins.is_started:
+            print("Function started")
+            ins.start() # 开始执行
+        else:
+            print("Function reset and started")
+            ins.reset()
+            ins.start()
+    
+    def execute_run_instrument(self):
+        process_found, process_pid = get_process_pid_by_name("Guide.exe", min_memory_mb=20)
+        if not process_found:
+            uiapp = connect_application(process=self._software_pid)
+            focus_on_application(uiapp)
+            ui_window: WindowSpecification = uiapp.app.top_window()
+            button: WindowSpecification = ui_window.child_window(title="xtpBarTop", class_name="XTPDockBar").child_window(
+                title="Standard", class_name="XTPToolBar").child_window(title="Protocol", control_type="Button")
+            click(button.wrapper_object())
+            for _ in range(5):
+                time.sleep(1)   
+                process_found, process_pid = get_process_pid_by_name("Guide.exe", min_memory_mb=20)
+                if process_found:
+                    break
+        if not process_found:
+            print("Guide.exe not found")
+            self._success = False
+            return False
+        uiapp = connect_application(process=process_pid)
+        self._guide_app = uiapp
+        focus_on_application(uiapp)
+        wrapper_object = uiapp.app.top_window().wrapper_object()
+        ui_path = get_ui_path_with_window_specification(wrapper_object)
+        self._executing_ui_path = ui_path
+        with ui_path:
+            try:
+                click(u"||Custom->||RadioButton-> Run||Text-> Run||Text")
+            except FailedSearch as e:
+                print(f"未找到Run按钮，可能已经在执行了")
+            with UIPath(u"WAA.Guide.Guide.RunControlViewModel||Custom->||Custom"):
+                click(u"Start||Button")
+            with UIPath(u"WAA.Guide.Guide.RunControlViewModel||Custom->||Custom->||Group->WAA.Guide.Guide.StartupControlViewModel||Custom->||Custom->Ok||Button"):
+                while self._executing_index is None or self._executing_index == 0:
+                    if exists(None, timeout=2):
+                        click(u"Ok||Text")
+                        print("Run Init Success!")
+                        self._is_executing_run = True
+                        return True
+                    else:
+                        print("Wait for Ok button")
+
+    def check_execute_run_status(self):
+        if not self._is_executing_run:
+            return False
+        if self._executing_ui_path is None:
+            return False
+        total_tasks = []
+        executing_index = 0
+        executing_status = ""
+        procedure_name_found = False
+        with self._executing_ui_path:
+            with UIPath(u"WAA.Guide.Guide.RunControlViewModel||Custom->||Custom"):
+                with UIPath("Progress||Group->||DataGrid"):
+                    wrappered_object: UIAWrapper = find(timeout=0.5)  # BUG: 在查找的时候会触发全局锁，建议还是使用Process来检测
+                    for custom_wrapper in wrappered_object.children():
+                        if len(custom_wrapper.children()) == 1:
+                            each_custom_wrapper = custom_wrapper.children()[0]
+                            if len(each_custom_wrapper.children()) == 2:
+                                if not procedure_name_found:
+                                    procedure_name_found = True
+                                    continue
+                                task_wrapper = each_custom_wrapper.children()[0]
+                                total_tasks.append(task_wrapper.window_text())
+                                status_wrapper = each_custom_wrapper.children()[1]
+                                status = status_wrapper.window_text()
+                                if len(status) > 0:
+                                    executing_index = len(total_tasks) - 1
+                                    executing_status = status
+        try:
+            if self._guide_app is not None:
+                wrapper_object = self._guide_app.app.top_window().wrapper_object()
+                ui_path = get_ui_path_with_window_specification(wrapper_object)
+                with ui_path:
+                    with UIPath("OK||Button"):
+                        btn = find(timeout=1)
+                        if btn is not None:
+                            btn.set_focus()
+                            click(btn, timeout=1)
+                            self._is_executing_run = False
+                            print("运行完成！")
+        except:
+            pass
+        self._executing_index = executing_index
+        self._executing_status = executing_status
+        self._total_tasks = total_tasks
+        return True
+
+    def initialize_instrument(self, force=False):
+        if not self._software_enabled:
+            print("Software is not opened")
+            self._success = False
+            return
+        if not self._http_service_available:
+            print("HTTP Server Not Available")
+            self._success = False
+            return
+        if self._is_initialized and not force:
+            print("Already Initialized")
+            self._success = True
+            return True
+        ins: SingleRunningExecutor = SingleRunningExecutor.get_instance(self.execute_initialize, lambda res, _: setattr(self, '_success', res))
+        if not ins.is_ended and ins.is_started:
+            print("Initialize is running")
+            self._success = False
+            return False
+        elif not ins.is_started:
+            print("Initialize started")
+            ins.start()
+        else:  # 可能外面is_initialized被设置为False，又进来重新初始化了
+            print("Initialize reset and started")
+            ins.reset()
+            ins.start()
+        return True
+
+    def execute_initialize(self, process=None) -> bool:
+        if process is None:
+            process = self._software_pid
+        try:
+            uiapp = connect_application(process=process)
+            ui_window: WindowSpecification = uiapp.app.top_window()
+
+            button = ui_window.child_window(title="xtpBarTop", class_name="XTPDockBar").child_window(
+                title="Standard", class_name="XTPToolBar").child_window(title="Initialize Instrument", control_type="Button")
+            focus_on_application(uiapp)
+            click(button.wrapper_object())
+            with get_ui_path_with_window_specification(ui_window):
+                with UIPath("Regex: (Initializing|Resetting|Perking).*||Window"):
+                    # 检测窗口是否存在
+                    for i in range(3):
+                        try:
+                            initializing_windows = exists(None, timeout=2)
+                            break
+                        except:
+                            pass
+                    print("window has recovered", initializing_windows)
+                    time.sleep(5)  # another wait
+            self._is_initialized = True
+            return True
+        except Exception as e:
+            print("An error occurred during initialization:")
+            traceback.print_exc()
+            return False
+
+    def __init__(self):
+        self._device_ip = "192.168.0.2"
+        # 启动所有监控器
+        self.checkers = [
+            ProcessChecker(self, 1),
+            HttpServiceChecker(self, 3),
+            RunStatusChecker(self, 1),
+            OkButtonChecker(self, 2)  # 添加新的Checker
+        ]
+        for checker in self.checkers:
+            checker.start_monitoring()
+
+
+class DriverChecker(ud.DriverChecker):
+    driver: NivoDriver
+
+class ProcessChecker(DriverChecker):
+    def check(self):
+        process_found, process_pid = get_process_pid_by_name("JANUS.exe", min_memory_mb=20)
+        self.driver._software_pid = process_pid
+        self.driver._software_enabled = process_found
+        if not process_found:
+            self.driver._is_initialized = False
+
+
+class HttpServiceChecker(DriverChecker):
+    def check(self):
+        http_service_available = False
+        if self.driver.device_ip:
+            try:
+                response = requests.get(f"http://{self.driver.device_ip}", timeout=5)
+                http_service_available = response.status_code == 200
+            except requests.RequestException:
+                pass
+        self.driver._http_service_available = http_service_available
+
+
+class RunStatusChecker(DriverChecker):
+    def check(self):
+        process_found, process_pid = get_process_pid_by_name("Guide.exe", min_memory_mb=20)
+        if not process_found:
+            self.driver._is_executing_run = False
+            return
+        self.driver.check_execute_run_status()
+
+class OkButtonChecker(DriverChecker):
+    def check(self):
+        if not self.driver._is_executing_run or self.driver._guide_app is None:
+            return
+        # uiapp = connect_application(process=11276)
+        # self.driver._guide_app = uiapp
+        try:
+            ui_window: UIAWrapper = self.driver._guide_app.app.top_window()
+            btn: WindowSpecification = ui_window.child_window(title="OK", auto_id="2", control_type="Button")
+            if btn.exists(2):
+                click(btn.wrapper_object())
+                self.driver._is_executing_run = False
+                print("运行完成！")
+        except Exception as e:
+            # traceback.print_exc()
+            pass
+
+# 示例用法
+if __name__ == "__main__":
+    driver = NivoDriver()
+    driver.set_device_addr("192.168.0.2")  # 设置设备 IP 地址
+    driver._is_executing_run = True

unilabos/devices/platereader/PlayerUtil.py

@@ -0,0 +1,166 @@
+import psutil
+import pywinauto
+from pywinauto_recorder import UIApplication
+from pywinauto_recorder.player import UIPath, click, focus_on_application, exists, find, get_wrapper_path
+from pywinauto.controls.uiawrapper import UIAWrapper
+from pywinauto.application import WindowSpecification
+from pywinauto import findbestmatch
+import sys
+import codecs
+import os
+import locale
+import six
+
+
+def connect_application(backend="uia", **kwargs):
+	app = pywinauto.Application(backend=backend)
+	app.connect(**kwargs)
+	top_window = app.top_window().wrapper_object()
+	native_window_handle = top_window.handle
+	return UIApplication(app, native_window_handle)
+
+def get_ui_path_with_window_specification(obj):
+	return UIPath(get_wrapper_path(obj))
+
+def get_process_pid_by_name(process_name: str, min_memory_mb: float = 0) -> tuple[bool, int]:
+    """
+    通过进程名称和最小内存要求获取进程PID
+    
+    Args:
+        process_name: 进程名称
+        min_memory_mb: 最小内存要求(MB)，默认为0表示不检查内存
+        
+    Returns:
+        tuple[bool, int]: (是否找到进程, 进程PID)
+    """
+    process_found = False
+    process_pid = None
+    min_memory_bytes = min_memory_mb * 1024 * 1024  # 转换为字节
+    
+    try:
+        for proc in psutil.process_iter(['name', 'pid', 'memory_info']):
+            try:
+                # 获取进程信息
+                proc_info = proc.info
+                if proc_info['name'] == process_name:
+                    # 如果设置了内存限制，则检查内存
+                    if min_memory_mb > 0:
+                        memory_info = proc_info.get('memory_info')
+                        if memory_info and memory_info.rss > min_memory_bytes:
+                            process_found = True
+                            process_pid = proc_info['pid']
+                            break
+                    else:
+                        # 不检查内存，直接返回找到的进程
+                        process_found = True
+                        process_pid = proc_info['pid']
+                        break
+                        
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+                
+    except Exception as e:
+        print(f"获取进程信息时发生错误: {str(e)}")
+        
+    return process_found, process_pid
+
+def print_wrapper_identifiers(wrapper_object, depth=None, filename=None):
+    """
+    打印控件及其子控件的标识信息
+    
+    Args:
+        wrapper_object: UIAWrapper对象
+        depth: 打印的最大深度,None表示打印全部
+        filename: 输出文件名,None表示打印到控制台
+    """
+    if depth is None:
+        depth = sys.maxsize
+        
+    # 创建所有控件的列表(当前控件及其所有子代)
+    all_ctrls = [wrapper_object, ] + wrapper_object.descendants()
+    
+    # 创建所有可见文本控件的列表
+    txt_ctrls = [ctrl for ctrl in all_ctrls if ctrl.can_be_label and ctrl.is_visible() and ctrl.window_text()]
+    
+    # 构建唯一的控件名称字典
+    name_ctrl_id_map = findbestmatch.UniqueDict()
+    for index, ctrl in enumerate(all_ctrls):
+        ctrl_names = findbestmatch.get_control_names(ctrl, all_ctrls, txt_ctrls)
+        for name in ctrl_names:
+            name_ctrl_id_map[name] = index
+            
+    # 反转映射关系(控件索引到名称列表)
+    ctrl_id_name_map = {}
+    for name, index in name_ctrl_id_map.items():
+        ctrl_id_name_map.setdefault(index, []).append(name)
+        
+    def print_identifiers(ctrls, current_depth=1, log_func=print):
+        """递归打印控件及其子代的标识信息"""
+        if len(ctrls) == 0 or current_depth > depth:
+            return
+            
+        indent = (current_depth - 1) * u"   | "
+        for ctrl in ctrls:
+            try:
+                ctrl_id = all_ctrls.index(ctrl)
+            except ValueError:
+                continue
+                
+            ctrl_text = ctrl.window_text()
+            if ctrl_text:
+                # 将多行文本转换为单行
+                ctrl_text = ctrl_text.replace('\n', r'\n').replace('\r', r'\r')
+                
+            output = indent + u'\n'
+            output += indent + u"{class_name} - '{text}'    {rect}\n"\
+                "".format(class_name=ctrl.friendly_class_name(),
+                          text=ctrl_text,
+                          rect=ctrl.rectangle())
+            output += indent + u'{}'.format(ctrl_id_name_map[ctrl_id])
+            
+            title = ctrl_text
+            class_name = ctrl.class_name()
+            auto_id = None
+            control_type = None
+            if hasattr(ctrl.element_info, 'automation_id'):
+                auto_id = ctrl.element_info.automation_id
+            if hasattr(ctrl.element_info, 'control_type'):
+                control_type = ctrl.element_info.control_type
+                if control_type:
+                    class_name = None  # 如果有control_type就不需要class_name
+                else:
+                    control_type = None # 如果control_type为空,仍使用class_name
+                    
+            criteria_texts = []
+            recorder_texts = []
+            if title:
+                criteria_texts.append(u'title="{}"'.format(title))
+                recorder_texts.append(f"{title}")
+            if class_name:
+                criteria_texts.append(u'class_name="{}"'.format(class_name))
+            if auto_id:
+                criteria_texts.append(u'auto_id="{}"'.format(auto_id))
+            if control_type:
+                criteria_texts.append(u'control_type="{}"'.format(control_type))
+                recorder_texts.append(f"||{control_type}")
+            if title or class_name or auto_id:
+                output += u'\n' + indent + u'child_window(' + u', '.join(criteria_texts) + u')' + " / " + "".join(recorder_texts)
+                
+            if six.PY3:
+                log_func(output)
+            else:
+                log_func(output.encode(locale.getpreferredencoding(), errors='backslashreplace'))
+                
+            print_identifiers(ctrl.children(), current_depth + 1, log_func)
+            
+    if filename is None:
+        print("Control Identifiers:")
+        print_identifiers([wrapper_object, ])
+    else:
+        log_file = codecs.open(filename, "w", locale.getpreferredencoding())
+        def log_func(msg):
+            log_file.write(str(msg) + os.linesep)
+        log_func("Control Identifiers:")
+        print_identifiers([wrapper_object, ], log_func=log_func)
+        log_file.close()
+