Kea2-python 0.2.5__tar.gz → 0.3.1__tar.gz

{kea2_python-0.2.5 → kea2_python-0.3.1}/Kea2_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Kea2-python
-Version: 0.2.5
+Version: 0.3.1
 Summary: A python library for supporting and customizing automated UI testing for mobile apps
 Author-email: Xixian Liang <xixian@stu.ecnu.edu.cn>
 Requires-Python: >=3.8
@@ -10,6 +10,7 @@ Requires-Dist: rtree>=1.3.0
 Requires-Dist: jinja2>=3.0.0
 Requires-Dist: uiautomator2>=3.3.3
 Requires-Dist: adbutils>=2.9.3
+Requires-Dist: setuptools>=75.3.2
 Dynamic: license-file
 
 

{kea2_python-0.2.5 → kea2_python-0.3.1}/Kea2_python.egg-info/requires.txt

@@ -2,3 +2,4 @@ rtree>=1.3.0
 jinja2>=3.0.0
 uiautomator2>=3.3.3
 adbutils>=2.9.3
+setuptools>=75.3.2

{kea2_python-0.2.5 → kea2_python-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Kea2-python
-Version: 0.2.5
+Version: 0.3.1
 Summary: A python library for supporting and customizing automated UI testing for mobile apps
 Author-email: Xixian Liang <xixian@stu.ecnu.edu.cn>
 Requires-Python: >=3.8
@@ -10,6 +10,7 @@ Requires-Dist: rtree>=1.3.0
 Requires-Dist: jinja2>=3.0.0
 Requires-Dist: uiautomator2>=3.3.3
 Requires-Dist: adbutils>=2.9.3
+Requires-Dist: setuptools>=75.3.2
 Dynamic: license-file
 
 

{kea2_python-0.2.5 → kea2_python-0.3.1}/kea2/bug_report_generator.py

@@ -3,7 +3,7 @@ import re
 from datetime import datetime
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, TypedDict, List, Deque, NewType, Union, Optional
+from typing import Dict, Tuple, TypedDict, List, Deque, NewType, Union, Optional
 from collections import deque
 from concurrent.futures import ThreadPoolExecutor
 
@@ -444,7 +444,7 @@ class BugReportGenerator:
             logger.error(f"Error when marking screenshots: {e}")
 
 
-    def _mark_screenshot_interaction(self, step_type: str, screenshot_name: str, action_type: str, position: Union[List, tuple]) -> bool:
+    def _mark_screenshot_interaction(self, step_type: str, screenshot_name: str, action_type: str, position: Union[List, Tuple]) -> bool:
         """
         Mark interaction on screenshot with colored rectangle
 
@@ -630,7 +630,7 @@ class BugReportGenerator:
         })
 
     def _process_script_info(self, property_name: str, state: str, step_index: int, screenshot: str,
-                             current_property: str, current_test: Dict, property_violations: Dict) -> tuple:
+                             current_property: str, current_test: Dict, property_violations: Dict) -> Tuple:
         """
         Process ScriptInfo step for property violations tracking
 
@@ -831,7 +831,7 @@ class BugReportGenerator:
         
         return property_execution_trend
 
-    def _load_crash_dump_data(self) -> tuple[List[Dict], List[Dict]]:
+    def _load_crash_dump_data(self) -> Tuple[List[Dict], List[Dict]]:
         """
         Load crash and ANR events from crash-dump.log file
 

{kea2_python-0.2.5 → kea2_python-0.3.1}/kea2/fastbotManager.py

@@ -3,7 +3,7 @@ from retry.api import retry_call
 from dataclasses import asdict
 import requests
 from time import sleep
-
+from pkg_resources import parse_version
 
 from uiautomator2.core import HTTPResponse, _http_request
 from kea2.adbUtils import ADBDevice, ADBStreamShell_V2
@@ -28,6 +28,7 @@ class FastbotManager:
         self._device_output_dir = None
         ADBDevice.setDevice(options.serial, options.transport_id)
         self.dev = ADBDevice()
+        self.android_release = parse_version(self.dev.getprop("ro.build.version.release"))
 
     def _activateFastbot(self) -> ADBStreamShell_V2:
         """
@@ -219,7 +220,7 @@ class FastbotManager:
         if self.thread.is_running():
             logger.info("Waiting for Fastbot to exit.")
             return self.thread.wait()
-        return self.thread.poll()
+        return self.thread.poll() if self.android_release >= parse_version("7.0") else 0
 
     def start(self):
         # kill the fastbot process if runing.

{kea2_python-0.2.5 → kea2_python-0.3.1}/kea2/keaUtils.py

@@ -4,7 +4,7 @@ import os
 from pathlib import Path
 import traceback
 import time
-from typing import Callable, Any, Deque, Dict, List, Literal, NewType, TypedDict, Union
+from typing import Callable, Any, Deque, Dict, List, Literal, NewType, Union
 from unittest import TextTestRunner, registerResult, TestSuite, TestCase, TextTestResult
 import random
 import warnings
@@ -14,8 +14,8 @@ from functools import wraps
 from kea2.bug_report_generator import BugReportGenerator
 from kea2.resultSyncer import ResultSyncer
 from kea2.logWatcher import LogWatcher
-from kea2.utils import TimeStamp, getProjectRoot, getLogger
-from kea2.u2Driver import StaticU2UiObject
+from kea2.utils import TimeStamp, catchException, getProjectRoot, getLogger, timer
+from kea2.u2Driver import StaticU2UiObject, StaticXpathUiObject
 from kea2.fastbotManager import FastbotManager
 from kea2.adbUtils import ADBDevice
 import uiautomator2 as u2
@@ -640,13 +640,10 @@ class KeaTestRunner(TextTestRunner):
                     _widgets = func(self.options.Driver.getStaticChecker())
                     _widgets = _widgets if isinstance(_widgets, list) else [_widgets]
                     for w in _widgets:
-                        if isinstance(w, StaticU2UiObject):
+                        if isinstance(w, (StaticU2UiObject, StaticXpathUiObject)):
                             xpath = w.selector_to_xpath(w.selector)
                             if xpath != '//error':
                                 blocked_set.add(xpath)
-                        elif isinstance(w, u2.xpath.XPathSelector):
-                            xpath = w._parent.xpath
-                            blocked_set.add(xpath)
                         else:
                             logger.error(f"block widget defined in {func.__name__} Not supported.")
                 except Exception as e:
@@ -673,6 +670,12 @@ class KeaTestRunner(TextTestRunner):
 
         return result
 
+    @timer(r"Generating bug report cost %cost_time seconds.")
+    @catchException("Error when generating bug report")
+    def _generate_bug_report(self):
+        logger.info("Generating bug report")
+        report_generator = BugReportGenerator(self.options.output_dir)
+        report_generator.generate_report()
 
     def __del__(self):
         """tearDown method. Cleanup the env.
@@ -680,16 +683,4 @@ class KeaTestRunner(TextTestRunner):
         if self.options.Driver:
             self.options.Driver.tearDown()
 
-        try:
-            start_time = time.time()
-            logger.info("Generating bug report")
-            report_generator = BugReportGenerator(self.options.output_dir)
-            report_generator.generate_report()
-
-            end_time = time.time()
-            generation_time = end_time - start_time
-
-            logger.info(f"Bug report generation completed in {generation_time:.2f} seconds")
-            
-        except Exception as e:
-            logger.error(f"Error generating bug report: {e}", flush=True)
+        self._generate_bug_report()

{kea2_python-0.2.5 → kea2_python-0.3.1}/kea2/u2Driver.py

@@ -1,12 +1,14 @@
+import functools
 import random
 import socket
+import time
 from time import sleep
 import uiautomator2 as u2
 import adbutils
 import types
 import rtree
 import re
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Union, Optional
 from http.client import HTTPResponse
 from lxml import etree
 from .absDriver import AbstractScriptDriver, AbstractStaticChecker, AbstractDriver
@@ -205,6 +207,122 @@ class StaticU2UiObject(u2.UiObject):
     def __getattr__(self, attr):
         return getattr(super(), attr)
 
+"""
+The definition of XpathStaticChecker
+"""
+class StaticXpathUiObject(u2.xpath.XPathSelector):
+    def __init__(self, session, selector):
+        self.session: U2StaticDevice = session
+        self.selector = selector
+
+    @property
+    def exists(self):
+        source = self.session.get_page_source()
+        return len(self.selector.all(source)) > 0
+
+    def __and__(self, value) -> 'StaticXpathUiObjectr':
+        s = u2.xpath.XPathSelector(self.selector)
+        s._next_xpath = u2.xpath.XPathSelector.create(value.selector)
+        s._operator = u2.xpath.Operator.AND
+        s._parent = self.selector._parent
+        self.selector = s
+        return self
+
+    def __or__(self, value) -> 'StaticXpathUiObject':
+        s = u2.xpath.XPathSelector(self.selector)
+        s._next_xpath = u2.xpath.XPathSelector.create(value.selector)
+        s._operator = u2.xpath.Operator.OR
+        s._parent = self.selector._parent
+        self.selector = s
+        return self
+
+    def selector_to_xpath(self, selector: u2.xpath.XPathSelector) -> str:
+        """
+            Convert an XPathSelector to a standard XPath expression.
+
+            Args:
+                selector: The XPathSelector object to convert.
+
+            Returns:
+                A standard XPath expression as a string.
+            """
+
+        def _handle_path(path):
+            if isinstance(path, u2.xpath.XPathSelector):
+                return self.selector_to_xpath(path)
+            elif isinstance(path, u2.xpath.XPath):
+                return str(path)
+            else:
+                return path
+
+        base_xpath = _handle_path(selector._base_xpath)
+        base_xpath = base_xpath.replace('//*', './/node')
+
+        if selector._operator is None:
+            return base_xpath
+        else:
+            print("Unsupported operator: {}".format(selector._operator))
+            return "//error"
+
+    def xpath(self, _xpath: Union[list, tuple, str]) -> 'StaticXpathUiObject':
+        """
+        add xpath to condition list
+        the element should match all conditions
+
+        Deprecated, using a & b instead
+        """
+        if isinstance(_xpath, (list, tuple)):
+            self.selector = functools.reduce(lambda a, b: a & b, _xpath, self)
+        else:
+            self.selector = self.selector & _xpath
+        return self
+
+    def child(self, _xpath: str) -> "StaticXpathUiObject":
+        """
+        add child xpath
+        """
+        if self.selector._operator or not isinstance(self.selector._base_xpath, u2.xpath.XPath):
+            raise u2.xpath.XPathError("can't use child when base is not XPath or operator is set")
+        new = self.selector.copy()
+        new._base_xpath = self.selector._base_xpath.joinpath(_xpath)
+        self.selector = new
+        return self
+
+    def get(self, timeout=None) -> "XMLElement":
+        """
+        Get first matched element
+
+        Args:
+            timeout (float): max seconds to wait
+
+        Returns:
+            XMLElement
+
+        """
+        if not self.exists:
+            return None
+        return self.get_last_match()
+
+    def get_last_match(self) -> "u2.xpath.XMLElement":
+        return self.selector.all(self.selector._last_source)[0]
+
+    def parent_exists(self, xpath: Optional[str] = None):
+        el = self.get()
+        if el is None:
+            return False
+        element = el.parent(xpath) if hasattr(el, 'parent') else None
+        return True if element is not None else False
+
+    def __getattr__(self, key: str):
+        """
+              In IPython console, attr:_ipython_canary_method_should_not_exist_ will be called
+              So here ignore all attr startswith _
+              """
+        if key.startswith("_"):
+            raise AttributeError("Invalid attr", key)
+        if not hasattr(u2.xpath.XMLElement, key):
+            raise AttributeError("Invalid attr", key)
+        return getattr(super(), key)
 
 def _get_bounds(raw_bounds):
     pattern = re.compile(r"\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]")
@@ -299,7 +417,8 @@ class U2StaticDevice(u2.Device):
     def xpath(self) -> u2.xpath.XPathEntry:
         def get_page_source(self):
             # print("[Debug] Using static get_page_source method")
-            return u2.xpath.PageSource.parse(self._d.xml_raw)
+            xml_raw = etree.tostring(self._d.xml, encoding='unicode')
+            return u2.xpath.PageSource.parse(xml_raw)
         xpathEntry = _XPathEntry(self)
         xpathEntry.get_page_source = types.MethodType(
             get_page_source, xpathEntry
@@ -316,10 +435,14 @@ class _XPathEntry(u2.xpath.XPathEntry):
         self.xpath = None
         super().__init__(d)
         
-    def __call__(self, xpath, source = None):
+    # def __call__(self, xpath, source = None):
         # TODO fully support xpath in widget.block.py
-        self.xpath = xpath
-        return super().__call__(xpath, source)
+        # self.xpath = xpath
+        # return super().__call__(xpath, source)
+    def __call__(self, xpath, source=None):
+        ui = StaticXpathUiObject(session=self, selector=u2.xpath.XPathSelector(xpath, source=source))
+        return ui
+
 
 
 class U2StaticChecker(AbstractStaticChecker):

kea2_python-0.3.1/kea2/utils.py

@@ -0,0 +1,112 @@
+import logging
+import os
+from pathlib import Path
+import traceback
+from typing import TYPE_CHECKING
+
+import time
+from functools import wraps
+if TYPE_CHECKING:
+    from .keaUtils import Options
+
+
+def getLogger(name: str) -> logging.Logger:
+    logger = logging.getLogger(name)
+
+    def enable_pretty_logging():
+        if not logger.handlers:
+            # Configure handler
+            handler = logging.StreamHandler()
+            handler.flush = lambda: handler.stream.flush()  # 确保每次都flush
+            formatter = logging.Formatter('[%(levelname)1s][%(asctime)s %(module)s:%(lineno)d pid:%(process)d] %(message)s')
+            handler.setFormatter(formatter)
+            logger.addHandler(handler)
+            logger.propagate = False
+
+    enable_pretty_logging()
+    return logger
+
+
+logger = getLogger(__name__)
+
+
+def singleton(cls):
+    _instance = {}
+
+    def inner():
+        if cls not in _instance:
+            _instance[cls] = cls()
+        return _instance[cls]
+    return inner
+
+@singleton
+class TimeStamp:
+    time_stamp = None
+
+    def getTimeStamp(cls):
+        if cls.time_stamp is None:
+            import datetime
+            cls.time_stamp = datetime.datetime.now().strftime('%Y%m%d%H_%M%S%f')
+        return cls.time_stamp
+
+
+from uiautomator2 import Device
+d = Device
+
+
+def getProjectRoot():
+    root = Path(Path.cwd().anchor)
+    cur_dir = Path.absolute(Path(os.curdir))
+    while not os.path.isdir(cur_dir / "configs"):
+        if cur_dir == root:
+            return None
+        cur_dir = cur_dir.parent
+    return cur_dir
+
+
+def timer(log_info: str=None):
+    """ ### Decorator to measure the execution time of a function.
+
+    This decorator can be used to wrap functions where you want to log the time taken for execution
+    
+    ### Usage:
+        - @timer("Function execution took %cost_time seconds.")
+        - @timer()  # If no log_info is provided, it will print the function name and execution time.
+    
+    `%cost_time` will be replaced with the actual time taken for execution.
+    """
+    def accept(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            start_time = time.time()
+            result = func(*args, **kwargs)
+            end_time = time.time()
+            if log_info:
+                logger.info(log_info.replace(r"%cost_time", f"{end_time - start_time:.4f}"))
+            else:
+                logger.info(f"Function '{func.__name__}' executed in {(end_time - start_time):.4f} seconds.")
+            return result
+        return wrapper
+    return accept
+
+
+def catchException(log_info: str):
+    """ ### Decorator to catch exceptions and print log info.
+
+    This decorator can be used to wrap functions that may raise exceptions,
+    allowing you to log a message when the exception is raised.
+
+    ### Usage:
+        - @catchException("An error occurred in the function ****.")
+    """
+    def accept(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                logger.info(log_info)
+                tb = traceback.format_exception(type(e), e, e.__traceback__.tb_next)
+                print(''.join(tb), end='', flush=True)
+        return wrapper
+    return accept

{kea2_python-0.2.5 → kea2_python-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "Kea2-python"
-version = "0.2.5"
+version = "0.3.1"
 description = "A python library for supporting and customizing automated UI testing for mobile apps"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -8,7 +8,8 @@ dependencies = [
     "rtree>=1.3.0",
     "jinja2>=3.0.0",
     "uiautomator2>=3.3.3",
-    "adbutils>=2.9.3"
+    "adbutils>=2.9.3",
+    "setuptools>=75.3.2",
 ]
 authors = [
     { name = "Xixian Liang", email = "xixian@stu.ecnu.edu.cn" }
@@ -22,3 +23,4 @@ include = ["kea2"]
 
 [tool.setuptools.package-data]
 kea2 = ["assets/**/*", "templates/**/*"]
+

kea2_python-0.2.5/kea2/utils.py

@@ -1,71 +0,0 @@
-import logging
-import os
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-import time
-from functools import wraps
-if TYPE_CHECKING:
-    from .keaUtils import Options
-
-
-def getLogger(name: str) -> logging.Logger:
-    logger = logging.getLogger(name)
-
-    def enable_pretty_logging():
-        if not logger.handlers:
-            # Configure handler
-            handler = logging.StreamHandler()
-            handler.flush = lambda: handler.stream.flush()  # 确保每次都flush
-            formatter = logging.Formatter('[%(levelname)1s][%(asctime)s %(module)s:%(lineno)d pid:%(process)d] %(message)s')
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-            logger.propagate = False
-
-    enable_pretty_logging()
-    return logger
-
-
-def singleton(cls):
-    _instance = {}
-
-    def inner():
-        if cls not in _instance:
-            _instance[cls] = cls()
-        return _instance[cls]
-    return inner
-
-@singleton
-class TimeStamp:
-    time_stamp = None
-
-    def getTimeStamp(cls):
-        if cls.time_stamp is None:
-            import datetime
-            cls.time_stamp = datetime.datetime.now().strftime('%Y%m%d%H_%M%S%f')
-        return cls.time_stamp
-
-
-from uiautomator2 import Device
-d = Device
-
-
-def getProjectRoot():
-    root = Path(Path.cwd().anchor)
-    cur_dir = Path.absolute(Path(os.curdir))
-    while not os.path.isdir(cur_dir / "configs"):
-        if cur_dir == root:
-            return None
-        cur_dir = cur_dir.parent
-    return cur_dir
-
-
-def timer(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        start_time = time.time()
-        result = func(*args, **kwargs)
-        end_time = time.time()
-        print(f"Function '{func.__name__}' executed in {(end_time - start_time):.4f} seconds.")
-        return result
-    return wrapper