Kea2-python 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

kea2/__init__.py

@@ -1 +1,3 @@
-from .keaUtils import KeaTestRunner, precondition, prob, max_tries, Options, interruptable,HybridTestRunner,kea2_breakpoint
+from .keaUtils import KeaTestRunner, precondition, prob, max_tries, Options, interruptable,HybridTestRunner,kea2_breakpoint
+from .kea2_api import Kea2Tester
+from .u2Driver import U2Driver

kea2/cli.py

@@ -95,13 +95,12 @@ def cmd_merge(args):
         # Merge test reports
         merged_report = merger.merge_reports(args.paths, args.output)
 
-        # Print results
-        print(f"✅ Test reports merged successfully!", flush=True)
-        print(f"📊 Merged report: {merged_report}", flush=True)
-
-        # Get merge summary
-        merge_summary = merger.get_merge_summary()
-        print(f"📈 Merged {merge_summary.get('merged_directories', 0)} directories", flush=True)
+        if merged_report is not None:
+            print(f"✅ Test reports merged successfully!", flush=True)
+            print(f"📊 Merged report: {merged_report}", flush=True)
+            # Get merge summary
+            merge_summary = merger.get_merge_summary()
+            print(f"📈 Merged {merge_summary.get('merged_directories', 0)} directories", flush=True)
 
     except Exception as e:
         logger.error(f"Error during merge operation: {e}")      

kea2/fastbotManager.py

@@ -41,62 +41,12 @@ class FastbotManager:
         :params: port: the listening port for script driver
         :return: the fastbot daemon thread
         """
-        cur_dir = Path(__file__).parent
-        self.dev.sync.push(
-            Path.joinpath(cur_dir, "assets/monkeyq.jar"),
-            "/sdcard/monkeyq.jar"
-        )
-        self.dev.sync.push(
-            Path.joinpath(cur_dir, "assets/fastbot-thirdpart.jar"),
-            "/sdcard/fastbot-thirdpart.jar",
-        )
-        self.dev.sync.push(
-            Path.joinpath(cur_dir, "assets/kea2-thirdpart.jar"),
-            "/sdcard/kea2-thirdpart.jar",
-        )
-        self.dev.sync.push(
-            Path.joinpath(cur_dir, "assets/framework.jar"),
-            "/sdcard/framework.jar",
-        )
-        self.dev.sync.push(
-            Path.joinpath(cur_dir, "assets/fastbot_libs/arm64-v8a/libfastbot_native.so"),
-            "/data/local/tmp/arm64-v8a/libfastbot_native.so",
-        )
-        self.dev.sync.push(
-            Path.joinpath(cur_dir, "assets/fastbot_libs/armeabi-v7a/libfastbot_native.so"),
-            "/data/local/tmp/armeabi-v7a/libfastbot_native.so",
-        )
-        self.dev.sync.push(
-            Path.joinpath(cur_dir, "assets/fastbot_libs/x86/libfastbot_native.so"),
-            "/data/local/tmp/x86/libfastbot_native.so",
-        )
-        self.dev.sync.push(
-            Path.joinpath(cur_dir, "assets/fastbot_libs/x86_64/libfastbot_native.so"),
-            "/data/local/tmp/x86_64/libfastbot_native.so",
-        )
-
-        cwd = getProjectRoot()
-        whitelist = self.options.act_whitelist_file
-        blacklist = self.options.act_blacklist_file
-        if bool(whitelist) ^ bool(blacklist):
-            if whitelist:
-                file_to_push = cwd / 'configs' / 'awl.strings'
-                remote_path = whitelist
-            else:
-                file_to_push = cwd / 'configs' / 'abl.strings'
-                remote_path = blacklist
-
-            self.dev.sync.push(
-                file_to_push,
-                remote_path
-            )
 
+        self._push_libs()
         t = self._startFastbotService()
         logger.info("Running Fastbot...")
-
         return t
 
-
     def check_alive(self):
         """
         check if the script driver and proxy server are alive.
@@ -183,6 +133,58 @@ class FastbotManager:
     @property
     def device_output_dir(self):
         return self._device_output_dir
+    
+    def _push_libs(self):
+        logger.info("Pushing Fastbot libraries to device...")
+        cur_dir = Path(__file__).parent
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/monkeyq.jar"),
+            "/sdcard/monkeyq.jar"
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot-thirdpart.jar"),
+            "/sdcard/fastbot-thirdpart.jar",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/kea2-thirdpart.jar"),
+            "/sdcard/kea2-thirdpart.jar",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/framework.jar"),
+            "/sdcard/framework.jar",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot_libs/arm64-v8a/libfastbot_native.so"),
+            "/data/local/tmp/arm64-v8a/libfastbot_native.so",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot_libs/armeabi-v7a/libfastbot_native.so"),
+            "/data/local/tmp/armeabi-v7a/libfastbot_native.so",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot_libs/x86/libfastbot_native.so"),
+            "/data/local/tmp/x86/libfastbot_native.so",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot_libs/x86_64/libfastbot_native.so"),
+            "/data/local/tmp/x86_64/libfastbot_native.so",
+        )
+
+        cwd = getProjectRoot()
+        whitelist = self.options.act_whitelist_file
+        blacklist = self.options.act_blacklist_file
+        if bool(whitelist) ^ bool(blacklist):
+            if whitelist:
+                file_to_push = cwd / 'configs' / 'awl.strings'
+                remote_path = whitelist
+            else:
+                file_to_push = cwd / 'configs' / 'abl.strings'
+                remote_path = blacklist
+
+            self.dev.sync.push(
+                file_to_push,
+                remote_path
+            )
 
     def _startFastbotService(self) -> ADBStreamShell_V2:
         shell_command = [

kea2/kea2_api.py

@@ -0,0 +1,166 @@
+from typing import Optional, List, Callable, Any, Union, Dict
+from pathlib import Path
+import unittest
+import os
+import inspect
+from .keaUtils import KeaTestRunner, Options
+from .u2Driver import U2Driver
+from .utils import getLogger, TimeStamp, setCustomProjectRoot
+from .adbUtils import ADBDevice
+
+logger = getLogger(__name__)
+
+
+class Kea2Tester:
+    """
+    Kea2 property tester
+    
+    This class allows users to directly launch Kea2 property tests in existing test scripts.
+    
+    Environment Variables:
+        KEA2_HYBRID_MODE: Controls whether to enable Kea2 testing
+            - "kea2": Enable Kea2 testing, trigger a breakpoint after testing is completed
+            - Other values or not set: Skip Kea2 testing, continue executing the original script
+            
+    """
+    
+    def __init__(self):
+        self.options: Optional[Options] = None
+        self.properties: List[unittest.TestCase] = []
+        self._caller_info: Optional[Dict[str, str]] = None
+    
+    def run_kea2_testing(self, option: Options, configs_path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
+        """
+        Launch kea2 property test
+        
+        Args:
+            option: Kea2 and Fastbot configuration options
+            configs_path: Your configs directory (absolute or relative path)
+        
+        Returns:
+            dict: Test result dictionary containing the following keys:
+                - executed (bool): Whether Kea2 testing was executed
+                - skipped (bool): Whether Kea2 testing was skipped (KEA2_HYBRID_MODE != kea2)
+                - caller_info (Dict|None): Caller information (file, class, method name)
+                - output_dir (Path|None): Test output directory
+                - bug_report (Path|None): Bug report HTML file path
+                - result_json (Path|None): Test result JSON file path
+                - log_file (Path|None): Fastbot log file path
+        
+        """
+
+        self._caller_info = self._get_caller_info()
+        
+        logger.info("Starting Kea2 property testing...")
+        logger.info(f"Kea2 test launch location:")
+        if self._caller_info:
+            logger.info(f"   File: {self._caller_info['file']}")
+            logger.info(f"   Class: {self._caller_info['class']}")
+            logger.info(f"   Method: {self._caller_info['method']}")
+
+        self.options = option
+        if self.options is None:
+            raise ValueError("Please set up the option config first.")
+
+        from kea2.utils import getProjectRoot
+        previous_root = getProjectRoot()
+        if configs_path is not None:
+            configs_dir = Path(configs_path).expanduser() 
+            if not configs_dir.exists() or not configs_dir.is_dir():
+                raise FileNotFoundError(f"Configs directory not found in the specified path: {configs_dir}")
+            else:
+                setCustomProjectRoot(configs_path)
+        
+        KeaTestRunner.setOptions(self.options)
+        argv = ["python3 -m unittest"] + self.options.propertytest_args
+        
+        logger.info("Starting Kea2 property test...")
+        runner = KeaTestRunner()
+        unittest.main(module=None, argv=argv, testRunner=runner, exit=False)
+        logger.info("Kea2 property test completed.")
+
+        if configs_path is not None:
+            setCustomProjectRoot(previous_root)
+        
+        result = self._build_test_result()
+        
+        return result
+    
+    def _build_test_result(self) -> Dict[str, Any]:
+        """
+        build test result dict
+        
+        Returns:
+            dict: Dictionary containing output directory and paths to various report files
+        """
+        if self.options is None:
+            return {
+                'executed': False,
+                'skipped': False,
+                'caller_info': self._caller_info,
+                'output_dir': None,
+                'bug_report': None,
+                'result_json': None,
+                'log_file': None
+            }
+        
+        output_dir = self.options.output_dir
+        
+        from .keaUtils import STAMP, LOGFILE, RESFILE
+        
+        bug_report_path = output_dir / "bug_report.html"
+        result_json_path = output_dir / RESFILE.name if hasattr(RESFILE, 'name') else output_dir / f"result_{STAMP}.json"
+        log_file_path = output_dir / LOGFILE.name if hasattr(LOGFILE, 'name') else output_dir / f"fastbot_{STAMP}.log"
+        
+        return {
+            'executed': True,
+            'skipped': False,
+            'caller_info': self._caller_info,
+            'output_dir': output_dir,
+            'bug_report': bug_report_path if bug_report_path.exists() else None,
+            'result_json': result_json_path if result_json_path.exists() else None,
+            'log_file': log_file_path if log_file_path.exists() else None
+        }
+    
+    def _get_caller_info(self) -> Dict[str, str]:
+        """
+        Get caller information (file, class, method name)
+        
+        Returns:
+            dict: Dictionary containing file, class, method
+        """
+        try:
+            frame = inspect.currentframe()
+            caller_frame = frame.f_back.f_back
+            
+            while caller_frame:
+                frame_info = inspect.getframeinfo(caller_frame)
+                if 'kea2_api.py' not in frame_info.filename:
+                    # find caller
+                    file_path = frame_info.filename
+                    method_name = frame_info.function
+                    
+                    # get class name
+                    class_name = None
+                    if 'self' in caller_frame.f_locals:
+                        class_name = caller_frame.f_locals['self'].__class__.__name__
+                    
+                    return {
+                        'file': file_path,
+                        'class': class_name or 'N/A',
+                        'method': method_name
+                    }
+                caller_frame = caller_frame.f_back
+            
+            return {
+                'file': 'Unknown',
+                'class': 'N/A',
+                'method': 'Unknown'
+            }
+        except Exception as e:
+            logger.warning(f"Failed to get caller info: {e}")
+            return {
+                'file': 'Unknown',
+                'class': 'N/A',
+                'method': 'Unknown'
+            }

kea2/keaUtils.py

@@ -23,7 +23,7 @@ from .report.bug_report_generator import BugReportGenerator
 from .resultSyncer import ResultSyncer
 from .logWatcher import LogWatcher
 from .utils import TimeStamp, catchException, getProjectRoot, getLogger, loadFuncsFromFile, timer
-from .u2Driver import StaticU2UiObject, StaticXpathUiObject, U2Driver
+from .u2Driver import StaticU2UiObject, StaticXpathObject, U2Driver
 from .fastbotManager import FastbotManager
 from .adbUtils import ADBDevice
 from .mixin import BetterConsoleLogExtensionMixin
@@ -45,7 +45,7 @@ PropName = NewType("PropName", str)
 PropertyStore = NewType("PropertyStore", Dict[PropName, TestCase])
 
 
-STAMP = TimeStamp().getTimeStamp()
+STAMP: str
 LOGFILE: str
 RESFILE: str
 PROP_EXEC_RESFILE: str
@@ -118,7 +118,7 @@ class Options:
     # the driver_name in script (if self.d, then d.) 
     driverName: str = None
     # the driver (only U2Driver available now)
-    Driver: AbstractDriver = None
+    Driver: AbstractDriver = U2Driver
     # list of package names. Specify the apps under test
     packageNames: List[str] = None
     # target device
@@ -154,7 +154,7 @@ class Options:
     # Activity BlackList File
     act_blacklist_file: str = None
     # propertytest sub-commands args (eg. discover -s xxx -p xxx)
-    propertytest_args: str = None
+    propertytest_args: List[str] = None
     # unittest sub-commands args (Feat 4)
     unittest_args: List[str] = None
     # Extra args (directly passed to fastbot)
@@ -172,10 +172,11 @@ class Options:
         if self.Driver:
             self._set_driver()
 
-        if self.log_stamp:
-            self._sanitize_custom_stamp()
-
         global STAMP
+        STAMP = self.log_stamp if self.log_stamp else TimeStamp().getTimeStamp()
+
+        self._sanitize_stamp()
+
         self.output_dir = Path(self.output_dir).absolute() / f"res_{STAMP}"
         self.set_stamp()
 
@@ -193,15 +194,14 @@ class Options:
         RESFILE = f"result_{STAMP}.json"
         PROP_EXEC_RESFILE = f"property_exec_info_{STAMP}.json"
 
-    def _sanitize_custom_stamp(self):
+    def _sanitize_stamp(self):
         global STAMP
         illegal_chars = ['/', '\\', ':', '*', '?', '"', '<', '>', '|', '\n', '\r', '\t', '\0']
         for char in illegal_chars:
-            if char in self.log_stamp:
+            if char in STAMP:
                 raise ValueError(
-                    f"char: `{char}` is illegal in --log-stamp. current stamp: {self.log_stamp}"
+                    f"char: `{char}` is illegal in --log-stamp. current stamp: {STAMP}"
                 )
-        STAMP = self.log_stamp
     
     def _sanitize_args(self):
         if not self.take_screenshots and self.pre_failure_screenshots > 0:
@@ -255,7 +255,7 @@ def _check_package_installation(packageNames):
     for package in packageNames:
         if package not in installed_packages:
             logger.error(f"package {package} not installed. Abort.")
-            raise ValueError("package not installed")
+            raise ValueError(f"{package} not installed")
 
 
 def _save_bug_report_configs(options: Options):
@@ -542,6 +542,11 @@ class KeaTestRunner(TextTestRunner, KeaOptionSetter):
             log_watcher.close()
         
         result.logSummary()
+
+        if self.options.agent == "u2":
+            self._generate_bug_report()
+
+        self.tearDown()
         return result
     
     def shouldStop(self, start_time):
@@ -554,7 +559,7 @@ class KeaTestRunner(TextTestRunner, KeaOptionSetter):
         r = self._get_block_widgets()
         r["steps_count"] = self.stepsCount
         return r
-    
+
     def _get_block_widgets(self):
         block_dict = self._getBlockedWidgets()
         block_widgets: List[str] = block_dict['widgets']
@@ -600,6 +605,8 @@ class KeaTestRunner(TextTestRunner, KeaOptionSetter):
                     continue
                 validProps[propName] = test
 
+        staticCheckerDriver.clear_cache()
+
         print(f"{len(validProps)} precond satisfied.", flush=True)
         if len(validProps) > 0:
             print("[INFO] Valid properties:",flush=True)
@@ -731,7 +738,7 @@ class KeaTestRunner(TextTestRunner, KeaOptionSetter):
                     _widgets = func(U2Driver.getStaticChecker())
                     _widgets = _widgets if isinstance(_widgets, list) else [_widgets]
                     for w in _widgets:
-                        if isinstance(w, (StaticU2UiObject, StaticXpathUiObject)):
+                        if isinstance(w, (StaticU2UiObject, StaticXpathObject)):
                             xpath = w.selector_to_xpath(w.selector)
                             if xpath != '//error':
                                 blocked_set.add(xpath)
@@ -767,14 +774,20 @@ class KeaTestRunner(TextTestRunner, KeaOptionSetter):
         logger.info("Generating bug report")
         BugReportGenerator(self.options.output_dir).generate_report()
 
-    def __del__(self):
+    def tearDown(self):
         """tearDown method. Cleanup the env.
         """
         if self.options.Driver:
             self.options.Driver.tearDown()
-
-        if self.options.agent == "u2":
-            self._generate_bug_report()
+    
+    def __del__(self):
+        """tearDown method. Cleanup the env.
+        """
+        try:
+            self.tearDown()
+        except Exception:
+            # Ignore exceptions in __del__ to avoid "Exception ignored" warnings
+            pass
 
 
 class KeaTextTestResult(BetterConsoleLogExtensionMixin, TextTestResult):
@@ -948,8 +961,12 @@ class HybridTestRunner(TextTestRunner, KeaOptionSetter):
     def __del__(self):
         """tearDown method. Cleanup the env.
         """
-        if self.options.Driver:
-            self.options.Driver.tearDown()
+        try:
+            if hasattr(self, 'options') and self.options and self.options.Driver:
+                self.options.Driver.tearDown()
+        except Exception:
+            # Ignore exceptions in __del__ to avoid "Exception ignored" warnings
+            pass
 
 
 def kea2_breakpoint():

kea2/logWatcher.py

@@ -46,7 +46,7 @@ class LogWatcher:
                 raise RuntimeError(
                     "[Error] Fatal Execption while running fastbot:\n" + 
                     exception_body + 
-                    "\nSee fastbot.log for details."
+                    f"\nSee {self.log_file} for details."
                 )
         
         statistic_match = PATTERN_STATISTIC.search(content)

kea2/report/bug_report_generator.py

@@ -280,7 +280,7 @@ class BugReportGenerator(CrashAnrMixin, PathParserMixin, ScreenshotsMixin):
                 info = step_data.get("Info", {})
 
                 # Count Monkey events separately
-                if step_type == "Monkey":
+                if step_type == "Monkey" or step_type == "Fuzz":
                     monkey_events_count += 1
 
                 # If screenshots are enabled, mark the screenshot

kea2/report/report_merger.py

@@ -20,9 +20,10 @@ class TestReportMerger:
     def __init__(self):
         self.merged_data = {}
         self.result_dirs = []
+        self._package_name: Optional[str] = None
     
     @catchException("Error merging reports")
-    def merge_reports(self, result_paths: List[Union[str, Path]], output_dir: Optional[Union[str, Path]] = None) -> Path:
+    def merge_reports(self, result_paths: List[Union[str, Path]], output_dir: Optional[Union[str, Path]] = None) -> Optional[Path]:
         """
         Merge multiple test result directories
         
@@ -31,10 +32,17 @@ class TestReportMerger:
             output_dir: Output directory for merged data (optional)
             
         Returns:
-            Path to the merged data directory
+            Path to the merged data directory, or None if validation fails
         """
         # Convert paths and validate
         self.result_dirs = [Path(p).resolve() for p in result_paths]
+        self._package_name = None
+
+        package_name, fatal_error = self._determine_package_name()
+        if fatal_error:
+            logger.error("Aborting merge because package validation failed.")
+            return None
+        self._package_name = package_name
         
         # Setup output directory
         timestamp = datetime.now().strftime("%Y%m%d%H_%M%S")
@@ -59,7 +67,8 @@ class TestReportMerger:
         final_data['merge_info'] = {
             'merge_timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             'source_count': len(self.result_dirs),
-            'source_directories': [str(Path(d).name) for d in self.result_dirs]
+            'source_directories': [str(Path(d).name) for d in self.result_dirs],
+            'package_name': self._package_name or ""
         }
 
         # Generate HTML report (now includes merge info)
@@ -67,6 +76,79 @@ class TestReportMerger:
         
         logger.debug(f"Reports generated successfully in: {output_dir}")
         return report_file
+
+    def _determine_package_name(self) -> Tuple[Optional[str], bool]:
+        """
+        Ensure all reports belong to the same application and return the shared package name.
+
+        Returns:
+            tuple: (package_name, fatal_error)
+                package_name: shared package name if determined, otherwise None
+                fatal_error: True if validation should stop the merge
+        """
+        if not self.result_dirs:
+            logger.error("No result directories provided for merge.")
+            return None, True
+
+        known_package: Optional[str] = None
+
+        for result_dir in self.result_dirs:
+            package_name, fatal_error = self._extract_package_name(result_dir)
+            if fatal_error:
+                return None, True
+            if package_name is None:
+                continue
+
+            if known_package is None:
+                known_package = package_name
+            elif package_name != known_package:
+                logger.error(
+                    f"Cannot merge reports generated for different applications: "
+                    f"{result_dir.name} uses package '{package_name}' while others use '{known_package}'."
+                )
+                return None, True
+
+        if known_package:
+            logger.debug(f"Validated application package for merge: {known_package}")
+        else:
+            logger.warning("No package information found in provided report directories. Proceeding without package validation.")
+        return known_package, False
+
+    def _extract_package_name(self, result_dir: Path) -> Tuple[Optional[str], bool]:
+        """
+        Extract the application package name from a report directory.
+        """
+        config_path = result_dir / "bug_report_config.json"
+        if not config_path.exists():
+            logger.warning(f"Skipping package validation for {result_dir}: bug_report_config.json not found.")
+            return None, False
+
+        try:
+            with open(config_path, "r", encoding="utf-8") as config_file:
+                config_data = json.load(config_file)
+        except Exception as exc:
+            logger.error(f"Failed to load bug_report_config.json from {result_dir}: {exc}")
+            return None, True
+        package_names = config_data.get("packageNames")
+        if isinstance(package_names, str):
+            package_name = package_names.strip()
+            if not package_name:
+                logger.error(f"Package name is empty in bug_report_config.json for {result_dir}")
+                return None, True
+            return package_name, False
+
+        if isinstance(package_names, list):
+            valid_names = [pkg.strip() for pkg in package_names if pkg and pkg.strip()]
+            if not valid_names:
+                logger.error(f"No valid packageNames found in bug_report_config.json for {result_dir}")
+                return None, True
+            if len(valid_names) > 1:
+                logger.error(f"Multiple packageNames found in {config_path}, only single package is supported.")
+                return None, True
+            return valid_names[0], False
+
+        logger.error(f"packageNames format is invalid in {config_path}")
+        return None, True
     
     def _merge_property_results(self, output_dir: Path = None) -> Tuple[Dict[str, Dict], Dict[str, List[Dict]]]:
         """
@@ -663,14 +745,17 @@ class TestReportMerger:
         if not self.result_dirs:
             return {}
         
-        return {
+        summary = {
             "merged_directories": len(self.result_dirs),
             "source_paths": [str(p) for p in self.result_dirs],
             "merge_timestamp": datetime.now().isoformat()
         }
+        if self._package_name:
+            summary["package_name"] = self._package_name
+        return summary
 
     @catchException("Error generating HTML report")
-    def _generate_html_report(self, data: Dict, output_dir: Path) -> str:
+    def _generate_html_report(self, data: Dict, output_dir: Path) -> Path:
         """
         Generate HTML report using the merged template
 
@@ -709,4 +794,4 @@ class TestReportMerger:
             f.write(html_content)
 
         logger.debug(f"HTML report generated: {report_file}")
-        return str(report_file)
+        return report_file

kea2/u2Driver.py

@@ -1,19 +1,20 @@
 import functools
-import random
-import socket
 from time import sleep
+from importlib.metadata import version
+
 import uiautomator2 as u2
 import adbutils
 import types
 import rtree
 import re
+
 from typing import List, Literal, Union, Optional
 from lxml import etree
+from packaging.version import Version
 from .absDriver import AbstractScriptDriver, AbstractStaticChecker, AbstractDriver
-from .adbUtils import list_forwards, remove_forward, create_forward
-from .utils import TimeStamp, getLogger
+from .adbUtils import list_forwards, remove_forward
+from .utils import getLogger
 
-TIME_STAMP = TimeStamp().getTimeStamp()
 
 import logging
 logging.getLogger("urllib3").setLevel(logging.INFO)
@@ -55,8 +56,7 @@ class U2ScriptDriver(AbstractScriptDriver):
             print("[INFO] Connecting to uiautomator2. Please wait ...")
             self.d = u2.connect(adb)
             sleep(5)
-            self.d._device_server_port = 8090
-
+        self.d._device_server_port = 8090
         return self.d
 
     def _remove_remote_port(self, port:int):
@@ -69,11 +69,16 @@ class U2ScriptDriver(AbstractScriptDriver):
                 remove_forward(local_spec=forward_local, device=self.deviceSerial)
 
     def tearDown(self):
-        # logger.debug("U2Driver tearDown: stop_uiautomator")
-        # self.d.stop_uiautomator()
-        # logger.debug("U2Driver tearDown: remove forward")
-        # self._remove_remote_port(8090)
-        pass
+        logger.debug("U2Driver tearDown: stop_uiautomator")
+        if self.d is None:
+            return
+        try:
+            self.d._device_server_port = 9008
+            self.d.stop_uiautomator()
+        except (OSError, AttributeError, RuntimeError) as e:
+            logger.debug(f"Error during uiautomator teardown (may be already closed): {e}")
+        except Exception as e:
+            logger.warning(f"Unexpected error during uiautomator teardown: {e}")
 
 """
 The definition of U2StaticChecker
@@ -205,10 +210,14 @@ class StaticU2UiObject(u2.UiObject):
     def __getattr__(self, attr):
         return getattr(super(), attr)
 
+
+class StaticXpathObject(u2.xpath.XPathSelector):
+    pass
+
 """
 The definition of XpathStaticChecker
 """
-class StaticXpathUiObject(u2.xpath.XPathSelector):
+class StaticXpathObjectV1(StaticXpathObject):
     def __init__(self, session, selector):
         self.session: U2StaticDevice = session
         self.selector = selector
@@ -218,7 +227,7 @@ class StaticXpathUiObject(u2.xpath.XPathSelector):
         source = self.session.get_page_source()
         return len(self.selector.all(source)) > 0
 
-    def __and__(self, value) -> 'StaticXpathUiObject':
+    def __and__(self, value) -> 'StaticXpathObject':
         s = u2.xpath.XPathSelector(self.selector)
         s._next_xpath = u2.xpath.XPathSelector.create(value.selector)
         s._operator = u2.xpath.Operator.AND
@@ -226,7 +235,7 @@ class StaticXpathUiObject(u2.xpath.XPathSelector):
         self.selector = s
         return self
 
-    def __or__(self, value) -> 'StaticXpathUiObject':
+    def __or__(self, value) -> 'StaticXpathObject':
         s = u2.xpath.XPathSelector(self.selector)
         s._next_xpath = u2.xpath.XPathSelector.create(value.selector)
         s._operator = u2.xpath.Operator.OR
@@ -262,7 +271,7 @@ class StaticXpathUiObject(u2.xpath.XPathSelector):
             print("Unsupported operator: {}".format(selector._operator))
             return "//error"
 
-    def xpath(self, _xpath: Union[list, tuple, str]) -> 'StaticXpathUiObject':
+    def xpath(self, _xpath: Union[list, tuple, str]) -> 'StaticXpathObject':
         """
         add xpath to condition list
         the element should match all conditions
@@ -275,7 +284,7 @@ class StaticXpathUiObject(u2.xpath.XPathSelector):
             self.selector = self.selector & _xpath
         return self
 
-    def child(self, _xpath: str) -> "StaticXpathUiObject":
+    def child(self, _xpath: str) -> "StaticXpathObject":
         """
         add child xpath
         """
@@ -322,6 +331,45 @@ class StaticXpathUiObject(u2.xpath.XPathSelector):
             raise AttributeError("Invalid attr", key)
         return getattr(super(), key)
 
+
+class StaticXpathObjectV2(StaticXpathObjectV1):
+    def __and__(self, value) -> 'StaticXpathObject':
+        s = u2.xpath.XPathSelector(self.selector)
+        s._next_xpath = u2.xpath.XPathSelector.create(value.selector)
+        s._operator = u2.xpath.Operator.AND
+        self.selector = s
+        return self
+
+    def __or__(self, value) -> 'StaticXpathObject':
+        s = u2.xpath.XPathSelector(self.selector)
+        s._next_xpath = u2.xpath.XPathSelector.create(value.selector)
+        s._operator = u2.xpath.Operator.OR
+        self.selector = s
+        return self
+
+    def get_last_match(self) -> "u2.xpath.XMLElement":
+        source = self.session.get_page_source()
+        return self.selector.all(source)[0]
+
+
+class StaticXpathUiObjectFactory:
+
+    _u2_version = None
+
+    @classmethod
+    def get_u2_version(cls):
+        if cls._u2_version is None:
+            cls._u2_version = Version(version("uiautomator2"))
+        return cls._u2_version
+
+    @classmethod
+    def create(cls, session, xpath, source) -> StaticXpathObject:
+        if cls.get_u2_version() <= Version("3.4.0"):
+            return StaticXpathObjectV1(session, selector=u2.xpath.XPathSelector(xpath, source=source))
+        elif cls.get_u2_version() >= Version("3.4.1"):
+            return StaticXpathObjectV2(session, selector=u2.xpath.XPathSelector(xpath))
+
+
 def _get_bounds(raw_bounds):
     pattern = re.compile(r"\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]")
     m = re.match(pattern, raw_bounds)
@@ -411,9 +459,11 @@ class _HindenWidgetFilter:
 
 
 class U2StaticDevice(u2.Device):
+
     def __init__(self, script_driver=None):
         self.xml: etree._Element = None
-        self._script_driver = script_driver
+        self._script_driver:u2.Device = script_driver
+        self._app_current = None
 
     def __call__(self, **kwargs):
         ui = StaticU2UiObject(session=self, selector=u2.Selector(**kwargs))
@@ -421,6 +471,14 @@ class U2StaticDevice(u2.Device):
             ui.jsonrpc = self._script_driver.jsonrpc
         return ui
 
+    def clear_cache(self):
+        self._app_current = None
+
+    def app_current(self):
+        if not self._app_current:
+            self._app_current = self._script_driver.app_current()
+        return self._app_current
+
     @property
     def xpath(self) -> u2.xpath.XPathEntry:
         def get_page_source(self):
@@ -432,32 +490,33 @@ class U2StaticDevice(u2.Device):
             get_page_source, xpathEntry
         )
         return xpathEntry
-    
+
     def __getattr__(self, attr):
         """Proxy other methods to script_driver"""
         logger.debug(f"{attr} not exists in static checker, proxy to script_driver.")
         return getattr(self._script_driver, attr)
 
+
 class _XPathEntry(u2.xpath.XPathEntry):
     def __init__(self, d):
         self.xpath = None
         super().__init__(d)
-        
+
     # def __call__(self, xpath, source = None):
         # TODO fully support xpath in widget.block.py
         # 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))
+        ui = StaticXpathUiObjectFactory.create(session=self, xpath=xpath, source=source)
         return ui
 
 
-
 class U2StaticChecker(AbstractStaticChecker):
     """
     This is the StaticChecker used to check the precondition.
     We use the static checker due to the performing issues when runing multi-properties.
-    
+
     *e.g. the following self.d use U2StaticChecker*
     ```
     @precondition(lambda self: self.d("battery").exists)
@@ -521,51 +580,15 @@ class U2Driver(AbstractDriver):
     @classmethod
     def tearDown(self):
         if self.scriptDriver:
-            self.scriptDriver.tearDown()
+            try:
+                self.scriptDriver.tearDown()
+            except Exception as e:
+                logger.debug(f"Error during U2Driver teardown: {e}")
 
 
 """
 Other Utils
 """
-def forward_port(self, remote: Union[int, str]) -> int:
-        """forward remote port to local random port"""
-        remote = 8090
-        if isinstance(remote, int):
-            remote = "tcp:" + str(remote)
-        for f in self.forward_list():
-            if (
-                f.serial == self._serial
-                and f.remote == remote
-                and f.local.startswith("tcp:")
-            ):  # yapf: disable
-                return int(f.local[len("tcp:"):])
-        local_port = get_free_port()
-        self.forward("tcp:" + str(local_port), remote)
-        logger.debug(f"forwading port: tcp:{local_port} -> {remote}")
-        return local_port
-
-def is_port_in_use(port: int) -> bool:
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        return s.connect_ex(('127.0.0.1', port)) == 0
-
-
-def get_free_port():
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.bind(('127.0.0.1', 0))
-        try:
-            return s.getsockname()[1]
-        finally:
-            s.close()
-    except OSError:
-        # bind 0 will fail on Manjaro, fallback to random port
-        # https://github.com/openatx/adbutils/issues/85
-        for _ in range(20):
-            port = random.randint(10000, 20000)
-            if not is_port_in_use(port):
-                return port
-        raise RuntimeError("No free port found")
-
 def set_covered_to_deepest_node(selector: u2.Selector):
 
     def find_deepest_nodes(node):
@@ -585,5 +608,3 @@ def set_covered_to_deepest_node(selector: u2.Selector):
 
     if deepest_node is not None:
         dict.update(deepest_node, {"covered": False})
-
-

kea2/utils.py

@@ -5,7 +5,7 @@ import time
 
 from pathlib import Path
 from functools import wraps
-from typing import Callable, Dict, Optional
+from typing import Callable, Dict, Optional, Union
 
 
 def singleton(cls):
@@ -70,13 +70,41 @@ class TimeStamp:
             import datetime
             cls.time_stamp = datetime.datetime.now().strftime('%Y%m%d%H_%M%S%f')
         return cls.time_stamp
+    
+    def getCurrentTimeStamp(cls):
+        import datetime
+        return datetime.datetime.now().strftime('%Y%m%d%H_%M%S%f')
 
 
 from uiautomator2 import Device
 d = Device
 
 
+_CUSTOM_PROJECT_ROOT: Optional[Path] = None
+
+
+def setCustomProjectRoot(configs_path: Optional[Union[str, Path]]):
+    """
+    Set a custom project root directory (containing the configs directory). Passing None can restore the default behavior.
+    """
+    global _CUSTOM_PROJECT_ROOT
+
+    if configs_path is None:
+        _CUSTOM_PROJECT_ROOT = None
+        return
+
+    candidate = Path(configs_path).expanduser()
+    if candidate.name == "configs":
+        candidate = candidate.parent
+
+    candidate = candidate.resolve()
+    _CUSTOM_PROJECT_ROOT = candidate
+
+
 def getProjectRoot():
+    if _CUSTOM_PROJECT_ROOT:
+        return _CUSTOM_PROJECT_ROOT
+
     root = Path(Path.cwd().anchor)
     cur_dir = Path.absolute(Path(os.curdir))
     while not os.path.isdir(cur_dir / "configs"):

{kea2_python-1.0.2.dist-info → kea2_python-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Kea2-python
-Version: 1.0.2
+Version: 1.0.4
 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
@@ -26,8 +26,11 @@ Dynamic: license-file
 
 Please contact Xixian Liang at [xixian@stu.ecnu.edu.cn](xixian@stu.ecnu.edu.cn) with your Wechat ID / QR code to be invited to the WeChat discussion group. Of course, we are also ready on GitHub to answer your questions/feedback.
 
-### Github repo link
-[https://github.com/ecnusse/Kea2](https://github.com/ecnusse/Kea2)
+####  Github repo [https://github.com/ecnusse/Kea2](https://github.com/ecnusse/Kea2)
+####  Gitee mirror [https://gitee.com/XixianLiang/Kea2](https://gitee.com/XixianLiang/Kea2)
+
+
+
 
 ### [点击此处：查看中文文档](README_cn.md) 
 
@@ -43,7 +46,7 @@ Please contact Xixian Liang at [xixian@stu.ecnu.edu.cn](xixian@stu.ecnu.edu.cn)
 
 Kea2 is an easy-to-use tool for fuzzing mobile apps. Its key *novelty* is able to fuse automated UI testing with scripts (usually written by human), thus empowering automated UI testing with human intelligence for effectively finding *crashing bugs* as well as *non-crashing functional (logic) bugs*. 
 
-Kea2 is currently built on top of [Fastbot](https://github.com/bytedance/Fastbot_Android), *an industrial-strength automated UI testing tool*, and [uiautomator2](https://github.com/openatx/uiautomator2), *an easy-to-use and stable Android automation library*.
+Kea2 is currently built on top of [Fastbot](https://github.com/ecnusse/Fastbot_Android) 3.0 (a modified/enhanced version of the original [FastBot](https://github.com/bytedance/Fastbot_Android) 2.0), *an industrial-strength automated UI testing tool from ByteDance*, and [uiautomator2](https://github.com/openatx/uiautomator2), *an easy-to-use and stable Android automation library*. 
 Kea2 currently targets [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) apps. 
 
 ## Novelty & Important features
@@ -90,7 +93,7 @@ Please let us know and willing to hear your feedback/questions if you are also u
 Kea2 currently works with:
 - [unittest](https://docs.python.org/3/library/unittest.html) as the testing framework to manage the scripts;
 - [uiautomator2](https://github.com/openatx/uiautomator2) as the UI test driver; 
-- [Fastbot](https://github.com/bytedance/Fastbot_Android) as the backend automated UI testing tool.
+- [Fastbot](https://github.com/bytedance/Fastbot_Android) as the backend automated UI testing tool. 
 
 In the future, Kea2 will be extended to support
 - [pytest](https://docs.pytest.org/en/stable/), another popular python testing framework;
@@ -208,7 +211,7 @@ You can find the full example in script `quicktest.py`, and run this script with
 
 ```bash
 # Launch Kea2 and load one single script quicktest.py.
-kea2 run -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 200 --driver-name d propertytest discover -p quicktest.py
+kea2 run -p it.feio.android.omninotes.alpha --running-minutes 10 --throttle 200 --driver-name d propertytest discover -p quicktest.py
 ```
 
 ## Feature 3(运行增强版Fastbot：加入自动断言)
@@ -243,7 +246,8 @@ For the preceding always-holding property, we can write the following script to
     )
     def test_input_box(self):
 
-        # genenerate a random non-empty string (this is also property-based testing by feeding random text inputs!)
+        # genenerate a random non-empty string (this is also property-based testing
+        #                                       by feeding random text inputs!)
         from hypothesis.strategies import text, ascii_letters
         random_str = text(alphabet=ascii_letters).example()
 
@@ -261,9 +265,7 @@ For the preceding always-holding property, we can write the following script to
 
 You can run this example by using the similar command line in Feature 2.
 
-## Feature 4 (Experimental feature, 实验中，脚本与遍历的混合测试)
-
-> This feature is still under development. We are looking forward to your feedback! Contact us if you're interested in this feature.
+## Feature 4(兼容已有脚本：通过前置脚本步骤到达特定层次)
 
 Kea2 supports reusing existing Ui test Scripts. We are inspired by the idea that: *The existing Ui test scripts usually cover important app functionalities and can reach deep app states. Thus, they can be used as good "guiding scripts" to drive Fastbot to explore important and deep app states.*
 
@@ -271,22 +273,54 @@ For example, you may already have some existing Ui test scripts "login and add a
 
 ### Example
 
-See [guide_scripts.py](guide_scripts.py) for a full example.
+Here are four example scripts in hybridetest_examples, each corresponding to different forms of user scripts, showing you how to launch kea2 in the existing code.
 
-By the decorator `@interruptable`, you can mark the testcase as "interruptable" so that Kea2 can recognize this script and launch fuzzing test after it returns. 
+Specifically:  
 
-Since the state of app is probably unpredicted after fuzzing tests, Kea2 provides a `common_teardown` function to clean up the environment between previous script and next script. The function can be manually specified in `configs/teardown.py`.
+* [u2_unittest_example.py](hybridtest_examples\u2_unittest_example.py) is a u2 script organized with unittest.
+* [u2_pytest_example.py](hybridtest_examples\u2_pytest_example.py) is a u2 script organized with pytest.
+* [appium_unittest_example.py](hybridtest_examples\appium_unittest_example.py) is an appium script organized with unittest.
+* [appium_pytest_example.py](hybridtest_examples\appium_pytest_example.py) is an appium script organized with pytest.
 
-You can find the full example in `guide_scripts.py`, `property_omninotes.py`  and `configs/teardown.py` .  You can run one of the following commands:
+Some notes:
 
-```bash
-# Guide with guide_scripts.py and launch fuzzing test after every script.
-kea2 run -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 500 --max-step 15 --driver-name d unittest discover -p guide_scripts.py 
+1. You can control whether to execute the kea2-related code you have written by modifying the condition of 'if'. This allows you to easily enable or disable kea2 operations in the same script. Here we use environment variable as an example.
+2. Since kea2 is driven by u2, if an appium-written script wants to launch kea2, it is necessary to first close the appium session. Remember to configure the parameter `"noReset": True` in `desired_caps` to avoid resetting the application when closing the session.
+3. You need to insert the following code template into your existing test cases: Here, you can add your own hook logic in the commented sections, including starting or stopping the appium session, cleaning up instances, etc. This depends on how you want to design the setup and teardown. Apart from that, you only need to configure the `option` parameter and `configs_path` parameter(where your directory `configs` located, btw, `configs`'s location dependon where you executed `kea2 init`), then pass it to the `run_kea2_testing` function.
 
-# Guide with guide_scripts.py and launch fuzzing test after every script(check properties during fuzzing).
-kea2 run -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 500 --max-step 15 --driver-name d unittest discover -p guide_scripts.py propertytest discover -p quickstart2.py
+```python
+from kea2 import Kea2Tester, Options, U2Driver
+
+if os.environ.get('KEA2_HYBRID_MODE', '').lower() == 'true': 
+    '''
+    Note: The if condition here can be modified as needed according to the actual 
+    situation of the project, the form of environment variables is just an example.    
+    '''
+
+    # close your driver session etc. here
+    # ...
+    
+    tester = Kea2Tester()
+    result = self.tester.run_kea2_testing(
+        Options(
+            driverName="d",
+            packageNames=[PACKAGE_NAME],
+            propertytest_args=["discover", "-p", "Omninotes_Sample.py"],
+            serial=DEVICE_SERIAL,
+            running_mins=2,
+            maxStep=20
+        ),
+        configs_path = None  # Default, if your configs folder is located in the root directory, miss this.           
+    )
+    
+    # restart your driver session or clean instance here
+    # ...
+    
+    return  # this make your following steps of this testcase not work
 ```
 
+
+
 ## Test Reports（测试报告）
 
 Kea2 automatically generates a HTML test report after each testing session. You can find the report in `output/` under your working directory.
@@ -379,7 +413,7 @@ kea2做了什么：
 
 > Guided, Stochastic Model-Based GUI Testing of Android Apps. ESEC/FSE 2017.  [pdf](https://dl.acm.org/doi/10.1145/3106237.3106298)
 
-### Maintainers/Contributors
+## Maintainers/Contributors
 
 Kea2 has been actively developed and maintained by the people in [ecnusse](https://github.com/ecnusse):
 
@@ -397,7 +431,13 @@ Kea2 has been actively developed and maintained by the people in [ecnusse](https
 
 Kea2 has also received many valuable insights, advices, feedbacks and lessons shared by several industrial people from Bytedance ([Zhao Zhang](https://github.com/zhangzhao4444), Yuhui Su from the Fastbot team), OPay (Tiesong Liu), WeChat (Haochuan Lu, Yuetang Deng), Huawei, Xiaomi and etc. Kudos!
 
-### Star History
+### Become a Contributor!
+
+Kea2 is an open-source project and we are calling for more contributors to join us!
+
+See [Developer guide](DEVELOP.md) for more details.
+
+## Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=ecnusse/Kea2&type=Date)](https://www.star-history.com/#ecnusse/Kea2&Date)
 

{kea2_python-1.0.2.dist-info → kea2_python-1.0.4.dist-info}/RECORD

@@ -1,21 +1,22 @@
-kea2/__init__.py,sha256=Vqf9XZkOau0Kz59tI4OJRRIOG1AnL45ZUuPrri99gFg,123
+kea2/__init__.py,sha256=pwPZ2yYzws2pZrAtjczbG-_R1iVeY-_azD73DgWhe_U,187
 kea2/absDriver.py,sha256=NzmsLs1Ojz-yEXctGAqj7aKBwAQW19zd83l65RABCe8,1288
 kea2/adbUtils.py,sha256=pSmVlXEu3edfGL56Ag2mLCX9yIMHephnsUXzXUUEwNU,19904
-kea2/cli.py,sha256=KufFfXf-hkoaFeCJSvUTa2RbkTAWu4SuF9fp44E_SZ4,6173
-kea2/fastbotManager.py,sha256=Q1__QH0RbWw5QWTEW_QWydHaUf4xbBu2BTCu6XNYUFA,8940
-kea2/keaUtils.py,sha256=vUFeADftbv0DO8Mw4jeF2lQl0WIV27yQVCr00SQZPsY,36772
+kea2/cli.py,sha256=kevMd2afcmvNEzQ8s8r84-gh01ic7jjalcGVAlch6SA,6206
+kea2/fastbotManager.py,sha256=cgA4G26I5bNOrgOpMQvgYfD4MZTP1TpNuh0RG7euaDA,9057
+kea2/kea2_api.py,sha256=MIpuR_HjVUhElhR9uNMCabTFc5VC463WXtZS9dKR_1c,6349
+kea2/keaUtils.py,sha256=GeDVZ6SD44N1017W2vhxvvdDsFiXABL0q78YA0txja4,37251
 kea2/kea_launcher.py,sha256=6bGaO2eNSoFFLf6vSA1t1OTIPtGadUAZpYf3RS-pcik,9598
-kea2/logWatcher.py,sha256=cThOZ_awbJZh1wjeT6rxvdG_cDZSuzpaJmcYv5-OjkI,2594
+kea2/logWatcher.py,sha256=KfdDIZjeQzv5CV-o5TlWU7WBTOOCzshElYTPk6BnJ0Y,2599
 kea2/mixin.py,sha256=2Z9c7BfI6Z-K970sK8FFzKeld0bFPDQWhmh9uuDy4BI,819
 kea2/resultSyncer.py,sha256=ZjtQfH1vY-u30EDhrJPfj_SNmGZC67uwL-oZCvekB5Q,2434
-kea2/u2Driver.py,sha256=SzkS9gRocKNBhsDl4BYQNy0X68p7EDupEpxUycRSmNc,20638
-kea2/utils.py,sha256=XNAEoF7DBru7BFyScbufZWFhGBdZ88EeL7jO0T8Ugik,4424
+kea2/u2Driver.py,sha256=6GKMXjTiMW6PP5oYd9j1-TXQO4irAvPA5ohVeiayEtM,21252
+kea2/utils.py,sha256=l0id-y8FKWxtAXR42RpIyLLPUOizlDWLHu07MofxyZY,5191
 kea2/version_manager.py,sha256=LGSD3OqgrI4LAwLDSa2G4WRVcDppY92s1SjlCMqsQ6c,3196
 kea2/assets/config_version.json,sha256=dYZRNo17hQq2SV45xxRCwDmykhsWWYI__w7vZXMHvXc,377
 kea2/assets/fastbot-thirdpart.jar,sha256=0SZ_OoZFWDGMnazgXKceHgKvXdUDoIa3Gb2bcifaikk,85664
 kea2/assets/framework.jar,sha256=rTluOJJKj2DFwh7ascXso1udYdWv00BxBwSQ3Vmv-fw,1149240
 kea2/assets/kea2-thirdpart.jar,sha256=HYdtG2gqDLuLb72dpK3lX-Y6QUNTrJ-bfQopU5aWpfo,359346
-kea2/assets/monkeyq.jar,sha256=9O7KprOjS0CHAINwvJSk1CL18zD7ylJlWt6uYitPdSE,114148
+kea2/assets/monkeyq.jar,sha256=Ew0tliCWqoo88VF84JPrzp4M9Qni7SEAomjqZAgY5iE,114874
 kea2/assets/quicktest.py,sha256=FM3dlWpkCmeB1dGr2_zV1VcdLnkhsKYgdwyKyEg1378,4109
 kea2/assets/fastbot_configs/abl.strings,sha256=Rn8_YEbVGOJqndIY_-kWnR5NaoFI-cuB-ij10Ddhl90,75
 kea2/assets/fastbot_configs/awl.strings,sha256=-j4980GoWQxGOM9ijAwXPQmziCwFBZJFmuiv2tOEaYI,101
@@ -26,20 +27,20 @@ kea2/assets/fastbot_configs/max.strings,sha256=k82GAAZZG7KbDI7bk7DUklp41WJJO7j-j
 kea2/assets/fastbot_configs/max.tree.pruning,sha256=dm0oesN75FFbVSkV7STDUmrNMpQUBEuO7Uymt6nEkBc,629
 kea2/assets/fastbot_configs/teardown.py,sha256=dW6xHzozh2vXTB1qfCxAlT0xcv5kFwzX7kW1FmLfNA0,363
 kea2/assets/fastbot_configs/widget.block.py,sha256=r9Njm2xSBls3GMDIHTPMdmlFRiOjJWuVsq2KiieWFXA,1272
-kea2/assets/fastbot_libs/arm64-v8a/libfastbot_native.so,sha256=tAFrG73pJi7XakRxSp9CavPHbexKvhC9NOMdt48IEuM,2006872
-kea2/assets/fastbot_libs/armeabi-v7a/libfastbot_native.so,sha256=UV8bhaiPoPKdd3q0vj3kSZqPR9anllai_tz_2QkMMbQ,1335372
-kea2/assets/fastbot_libs/x86/libfastbot_native.so,sha256=k-aw1gEXRWMKZRNHIggKNuZy0wC1y2BnveJGEIO6rbo,2036856
-kea2/assets/fastbot_libs/x86_64/libfastbot_native.so,sha256=tiofhlf4uMQcU5WAvrdLgTBME0lb83hVUoGtTwxmE8A,2121416
+kea2/assets/fastbot_libs/arm64-v8a/libfastbot_native.so,sha256=gh19xaSrZsEzDZrNriM9fQ2WO8infYHoNgVt4cVelnM,2011128
+kea2/assets/fastbot_libs/armeabi-v7a/libfastbot_native.so,sha256=Z96EQOvoihtiLhWO1ca_EZ0vyeBPSMFLHYAgvjWTl-8,1338676
+kea2/assets/fastbot_libs/x86/libfastbot_native.so,sha256=wC9wGxx6JozPaEoxRXZI4aMQ-HZ2mvM63Loyog3V9Qs,2042160
+kea2/assets/fastbot_libs/x86_64/libfastbot_native.so,sha256=D2BBzBt5Tk-RwX38YL45OiGKKf2cZVFw_Vbr6WWJn68,2126440
 kea2/report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kea2/report/bug_report_generator.py,sha256=preCSHX1pUOqsPQmf5GJbkQROrNrFMH898a2Z9FMedc,30854
+kea2/report/bug_report_generator.py,sha256=PUh3YACRhpQwgDScCQGOSlOU2V6cakBRL-XSRq4vcck,30877
 kea2/report/mixin.py,sha256=XtWHOW4wF3lI41PRxdRpq3qxnmaGOAy32TZ0aSLCuvI,18659
-kea2/report/report_merger.py,sha256=9x8mjOV9Lnf6sSCNL7oiiCeRk0-KmuiqdwAxUDfRGtc,27057
+kea2/report/report_merger.py,sha256=U_arfWBtjkaqEETJLhIvD9UTW8-XohBLwunn4GNgSNQ,30800
 kea2/report/utils.py,sha256=r-oPtqbSDo8X0-V7zoIrz49TJ2-w-W444DS0de67mtk,344
 kea2/report/templates/bug_report_template.html,sha256=18Gpk8VPeO7TKN-_SEeDHG-XDiujlnA8PBvmaKGrbes,159182
 kea2/report/templates/merged_bug_report_template.html,sha256=iQHDW_XNVXfdAArPioELsgBcj1nAj9mmklqSVXGDQjQ,146912
-kea2_python-1.0.2.dist-info/licenses/LICENSE,sha256=nM9PPjcsXVo5SzNsjRqWgA-gdJlwqZZcRDSC6Qf6bVE,2034
-kea2_python-1.0.2.dist-info/METADATA,sha256=vga4APabMF9sVm_VkV_iuAaUz46s1Ki-LfLV1sz7gDs,23856
-kea2_python-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kea2_python-1.0.2.dist-info/entry_points.txt,sha256=mFX06TyxXiUAJQ6JZn8QHzfn8n5R8_KJ5W-pTm_fRCA,39
-kea2_python-1.0.2.dist-info/top_level.txt,sha256=TsgNH4PQoNOVhegpO7AcjutMVWp6Z4KDL1pBH9FnMmk,5
-kea2_python-1.0.2.dist-info/RECORD,,
+kea2_python-1.0.4.dist-info/licenses/LICENSE,sha256=nM9PPjcsXVo5SzNsjRqWgA-gdJlwqZZcRDSC6Qf6bVE,2034
+kea2_python-1.0.4.dist-info/METADATA,sha256=B6H3sT3uGlVGn6OlprCfM_GyE69SxC9JLjT0iDrxgDQ,25631
+kea2_python-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kea2_python-1.0.4.dist-info/entry_points.txt,sha256=mFX06TyxXiUAJQ6JZn8QHzfn8n5R8_KJ5W-pTm_fRCA,39
+kea2_python-1.0.4.dist-info/top_level.txt,sha256=TsgNH4PQoNOVhegpO7AcjutMVWp6Z4KDL1pBH9FnMmk,5
+kea2_python-1.0.4.dist-info/RECORD,,