Kea2-python 1.1.3b0__tar.gz → 1.1.3b2__tar.gz

{kea2_python-1.1.3b0 → kea2_python-1.1.3b2}/Kea2_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Kea2-python
-Version: 1.1.3b0
+Version: 1.1.3b2
 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: flatbuffers>=25.9.23
 Requires-Dist: packaging>=25.0
 Dynamic: license-file
 

{kea2_python-1.1.3b0 → kea2_python-1.1.3b2}/Kea2_python.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ kea2/adbUtils.py
 kea2/cli.py
 kea2/fastbotManager.py
 kea2/fbm_parser.py
+kea2/fbm_plugin.py
 kea2/fs_lock.py
 kea2/kea2_api.py
 kea2/keaUtils.py

{kea2_python-1.1.3b0 → kea2_python-1.1.3b2}/Kea2_python.egg-info/requires.txt

@@ -2,4 +2,5 @@ rtree>=1.3.0
 jinja2>=3.0.0
 uiautomator2>=3.3.3
 adbutils>=2.9.3
+flatbuffers>=25.9.23
 packaging>=25.0

{kea2_python-1.1.3b0 → kea2_python-1.1.3b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Kea2-python
-Version: 1.1.3b0
+Version: 1.1.3b2
 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: flatbuffers>=25.9.23
 Requires-Dist: packaging>=25.0
 Dynamic: license-file
 

kea2_python-1.1.3b2/kea2/adbUtils.py

@@ -0,0 +1,247 @@
+import sys
+import threading
+
+from typing import IO, Generator, Optional, List, Union, List, Optional, Set, Tuple
+
+from adbutils import AdbDevice, adb
+
+from .utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class ADBDevice(AdbDevice):
+    _instance = None
+    serial: Optional[str] = None
+    transport_id: Optional[str] = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def setDevice(cls, serial: Optional[str] = None, transport_id: Optional[str] = None):
+        ADBDevice.serial = serial or ADBDevice.serial
+        ADBDevice.transport_id = transport_id or ADBDevice.transport_id
+    
+    def __init__(self) -> AdbDevice:
+        """
+        Initializes the ADBDevice instance.
+        
+        Parameters:
+            device (str, optional): The device serial number. If None, it is resolved automatically when only one device is connected.
+            transport_id (str, optional): The transport ID for the device.
+        """
+        if not ADBDevice.serial and not ADBDevice.transport_id:
+            devices = [d.serial for d in adb.list() if d.state == "device"]
+            if len(devices) > 1:
+                raise RuntimeError("Multiple devices connected. Please specify a device")
+            if len(devices) == 0:
+                raise RuntimeError("No device connected.")
+            ADBDevice.serial = devices[0]
+        super().__init__(client=adb, serial=ADBDevice.serial, transport_id=ADBDevice.transport_id)
+
+    @property
+    def stream_shell(self) -> "StreamShell":
+        if "shell_v2" in self.get_features():
+            return ADBStreamShell_V2(session=self)
+        logger.warning("Using ADBStreamShell_V1. All output will be printed to stdout.")
+        return ADBStreamShell_V1(session=self)
+
+    def kill_proc(self, proc_name):
+        r = self.shell(f"ps -ef")
+        pids = [l for l in r.splitlines() if proc_name in l]
+        if pids:
+            logger.info(f"{proc_name} running, trying to kill it.")
+            pid = pids[0].split()[1]
+            self.shell(f"kill {pid}")
+
+
+class StreamShell:
+    def __init__(self, session: "ADBDevice"):
+        self.dev: ADBDevice = session
+        self._thread: threading.Thread = None
+        self._exit_code = 255
+        self.stdout = sys.stdout
+        self.stderr = sys.stderr
+        self._finished = False
+
+    def __call__(self, cmdargs: Union[List[str], str], stdout: IO = None, 
+                 stderr: IO = None, timeout: Union[float, None] = None) -> "StreamShell":
+        pass
+
+    def _write_stdout(self, data: bytes, decode=True):
+        text = data.decode('utf-8', errors='ignore') if decode else data
+        self.stdout.write(text)
+        self.stdout.flush()
+
+    def _write_stderr(self, data: bytes, decode=True):
+        text = data.decode('utf-8', errors='ignore') if decode else data
+        self.stderr.write(text)
+        self.stderr.flush()
+    
+    def wait(self):
+        """ Wait for the shell command to finish and return the exit code.
+        Returns:
+            int: The exit code of the shell command.
+        """
+        if self._thread:
+            self._thread.join()
+        return self._exit_code
+
+    def is_running(self) -> bool:
+        """ Check if the shell command is still running.
+        Returns:
+            bool: True if the command is still running, False otherwise.
+        """
+        return not self._finished and self._thread and self._thread.is_alive()
+    
+    def poll(self):
+        """
+        Check if the shell command is still running.
+        Returns:
+            int: The exit code if the command has finished, None otherwise.
+        """
+        if self._thread and self._thread.is_alive():
+            return None
+        return self._exit_code
+    
+    def join(self):
+        if self._thread and self._thread.is_alive():
+            self._thread.join()
+
+
+class ADBStreamShell_V1(StreamShell):
+
+    def __call__(
+        self, cmdargs: Union[List[str], str], stdout: IO = None, 
+        stderr: IO = None, timeout: Union[float, None] = None
+    ) -> "StreamShell":
+        return self.shell_v1(cmdargs, stdout, stderr, timeout)
+    
+    def shell_v1(
+        self, cmdargs: Union[List[str], str],
+        stdout: IO = None, stderr: IO = None,
+        timeout: Union[float, None] = None
+    ):
+        self._finished = False
+        self.stdout: IO = stdout if stdout else sys.stdout
+        self.stderr: IO = stderr if stderr else sys.stderr
+
+        cmd = " ".join(cmdargs) if isinstance(cmdargs, list) else cmdargs
+        self._generator = self._shell_v1(cmd, timeout)
+        self._thread = threading.Thread(target=self._process_output, daemon=True)
+        self._thread.start()
+        return self
+    
+    
+    def _shell_v1(self, cmdargs: str, timeout: Optional[float] = None) -> Generator[Tuple[str, str], None, None]:
+        if not isinstance(cmdargs, str):
+            raise RuntimeError("_shell_v1 args must be str")
+        MAGIC = "X4EXIT:"
+        newcmd = cmdargs + f"; echo {MAGIC}$?"
+        with self.dev.open_transport(timeout=timeout) as c:
+            c.send_command(f"shell:{newcmd}")
+            c.check_okay()
+            with c.conn.makefile("r", encoding="utf-8") as f:
+                for line in f:
+                    rindex = line.rfind(MAGIC)
+                    if rindex == -1:
+                        yield "output", line
+                        continue
+
+                    yield "exit", line[rindex + len(MAGIC):]
+                    return
+
+    def _process_output(self):
+        try:
+            for msg_type, data in self._generator:
+
+                if msg_type == 'output':
+                    self._write_stdout(data, decode=False)
+                elif msg_type == 'exit':
+                    # TODO : handle exit code properly
+                    # self._exit_code = int(data.strip())
+                    self._exit_code = 0
+                    break
+
+        except Exception as e:
+            print(f"ADBStreamShell execution error: {e}")
+            self._exit_code = -1
+
+
+class ADBStreamShell_V2(StreamShell):
+    def __init__(self, session: "ADBDevice"):
+        self.dev: ADBDevice = session
+        self._thread = None
+        self._exit_code = 255
+
+    def __call__(
+        self, cmdargs: Union[List[str], str], stdout: IO = None, 
+        stderr: IO = None, timeout: Union[float, None] = None
+    ) -> "StreamShell":
+        return self.shell_v2(cmdargs, stdout, stderr, timeout)
+    
+    def shell_v2(
+        self, cmdargs: Union[List[str], str],
+        stdout: IO = None, stderr: IO = None,
+        timeout: Union[float, None] = None
+    ):
+        """ Start a shell command on the device and stream its output. 
+        Args:
+            cmdargs (Union[List[str], str]): The command to execute, either as a list of arguments or a single string.
+            stdout (IO, optional): The output stream for standard output. Defaults to sys.stdout.
+            stderr (IO, optional): The output stream for standard error. Defaults to sys.stderr.
+            timeout (Union[float, None], optional): Timeout for the command execution. Defaults to None.
+        Returns:
+            ADBStreamShell: An instance of ADBStreamShell that can be used to interact with the shell command.
+        """
+        self._finished = False
+        self.stdout: IO = stdout if stdout else sys.stdout
+        self.stderr: IO = stderr if stderr else sys.stderr
+
+        cmd = " ".join(cmdargs) if isinstance(cmdargs, list) else cmdargs
+        self._generator = self._shell_v2(cmd, timeout)
+        self._thread = threading.Thread(target=self._process_output, daemon=True)
+        self._thread.start()
+        return self
+
+    def _process_output(self):
+        try:
+            for msg_type, data in self._generator:
+
+                if msg_type == 'stdout':
+                    self._write_stdout(data)
+                elif msg_type == 'stderr':
+                    self._write_stderr(data)
+                elif msg_type == 'exit':
+                    self._exit_code = data
+                    break
+
+        except Exception as e:
+            print(f"ADBStreamShell execution error: {e}")
+            self._exit_code = -1
+
+    def _shell_v2(self, cmd, timeout) -> Generator[Tuple[str, bytes], None, None]:
+        with self.dev.open_transport(timeout=timeout) as c:
+            c.send_command(f"shell,v2:{cmd}")
+            c.check_okay()
+
+            while True:
+                header = c.read_exact(5)
+                msg_id = header[0]
+                length = int.from_bytes(header[1:5], byteorder="little")
+
+                if length == 0:
+                    continue
+
+                data = c.read_exact(length)
+
+                if msg_id == 1:
+                    yield ('stdout', data)
+                elif msg_id == 2:
+                    yield ('stderr', data)
+                elif msg_id == 3:
+                    yield ('exit', data[0])
+                    break

{kea2_python-1.1.3b0 → kea2_python-1.1.3b2}/kea2/fbm_parser.py

@@ -578,13 +578,12 @@ class FBMMerger:
         Returns True on success (or if nothing to do), False on failure.
         """
         try:
-            from kea2.adbUtils import pull_file
-        except Exception:
-            try:
-                from adbUtils import pull_file  # type: ignore
-            except Exception as e:
-                print("ADB utilities not available:", e)
-                return False
+            # Use upstream adbutils directly (avoids relying on removed wrapper helpers)
+            from adbutils import adb
+            dev = adb.device(device) if device else adb.device()
+        except Exception as e:
+            print("ADB utilities (adbutils) not available:", e)
+            return False
 
         pc_dir = self._pc_dir
         pc_dir.mkdir(parents=True, exist_ok=True)
@@ -597,9 +596,9 @@ class FBMMerger:
         remote = self._remote_fbm_path(package_name)
         try:
             print(f"Attempting to pull {remote} to {pulled_tmp}")
-            pull_file(remote, str(pulled_tmp), device=device, transport_id=transport_id)
+            dev.sync.pull(remote, str(pulled_tmp))
         except Exception as e:
-            print(f"pull_file failed for {remote}: {e}")
+            print(f"dev.sync.pull failed for {remote}: {e}")
 
         if not pulled_tmp.exists() or pulled_tmp.stat().st_size == 0:
             print(f"No FBM on device for {package_name}, nothing merged to PC.")
@@ -617,7 +616,7 @@ class FBMMerger:
         try:
             # attempt to pull snapshot (may fail silently)
             try:
-                pull_file(snapshot_remote, str(pulled_snap_tmp), device=device, transport_id=transport_id)
+                dev.sync.pull(snapshot_remote, str(pulled_snap_tmp))
             except Exception:
                 # snapshot may not exist on device; ignore error and proceed (treat as empty)
                 pass
@@ -676,25 +675,25 @@ class FBMMerger:
         src = self._remote_fbm_path(package_name)
         dst = snapshot_remote or f"/sdcard/fastbot_{package_name}.snapshot.fbm"
         try:
-            from kea2.adbUtils import adb_shell, pull_file, push_file
-        except Exception:
-            try:
-                from adbUtils import adb_shell, pull_file, push_file  # type: ignore
-            except Exception as e:
-                print("ADB utilities not available:", e)
-                return False
+            # Prefer using adbutils directly for shell commands
+            from adbutils import adb
+            dev = adb.device(device) if device else adb.device()
+        except Exception as e:
+            print("ADB utilities not available:", e)
+            return False
 
         try:
             print(f"Creating device snapshot: cp {src} {dst}")
-            adb_shell(["cp", src, dst], device=device, transport_id=transport_id)
+            # use device.shell (string) to avoid subprocess-specific flags like -t
+            dev.shell(f'cp "{src}" "{dst}"')
             return True
         except Exception as e:
             print(f"adb shell cp failed ({e}), trying pull/push fallback")
             # fallback: pull then push to dst
             try:
                 pc_tmp = os.path.join(self._pc_dir, f"fastbot_{package_name}.snapshot.from_device.fbm")
-                pull_file(src, pc_tmp, device=device, transport_id=transport_id)
-                push_file(pc_tmp, dst, device=device, transport_id=transport_id)
+                dev.sync.pull(src, pc_tmp)
+                dev.sync.push(pc_tmp, dst)
                 try:
                     os.remove(pc_tmp)
                 except Exception:
@@ -865,7 +864,3 @@ class FBMMerger:
             print(f"Timeout acquiring lock to merge/apply delta into {pc_fbm}")
             return False
 
-
-
-
-

kea2_python-1.1.3b2/kea2/fbm_plugin.py

@@ -0,0 +1,98 @@
+import logging
+import functools
+from typing import TYPE_CHECKING
+from retry import retry
+
+
+if TYPE_CHECKING:
+    from .keaUtils import KeaTestRunner, Options
+
+
+from .adbUtils import ADBDevice
+from .utils import catchException
+
+
+logger = logging.getLogger(__name__)
+
+
+class FBMSanapshotCreationError(RuntimeError):
+    pass
+
+
+
+@catchException("Error creating device FBM snapshots")
+@retry(exceptions=FBMSanapshotCreationError, tries=3, delay=3)
+def create_device_snapshots(options: "Options") -> None:
+    """Create on-device snapshot copies of fastbot fbm files for configured packages.
+
+    Behavior:
+    - Only runs when options.download_fbm is truthy.
+    - Uses ADBDevice.shell (no subprocess) and retries cp up to max_retries.
+    - Logs errors and never raises to avoid blocking startup.
+    """
+
+    for pkg in options.packageNames:
+        src = f"/sdcard/fastbot_{pkg}.fbm"
+        dst = f"/sdcard/fastbot_{pkg}.snapshot.fbm"
+
+        try:
+            # Check src existence
+            check_cmd = f'test -f "{src}" && echo OK || echo NO'
+            check_src = ADBDevice().shell(check_cmd)
+            if not (isinstance(check_src, str) and "OK" in check_src):
+                print(f"Source FBM not found on device for package {pkg}: {src}. Skipping snapshot creation.", flush=True)
+                continue
+        except Exception as e:
+            logger.error(f"Failed to verify source FBM existence for {pkg}: {e}. Skipping.")
+            continue
+        
+        ADBDevice().shell(f'cp "{src}" "{dst}"')
+
+        # verify snapshot exists
+        verify_cmd = f'test -f "{dst}" && echo OK || echo NO'
+        r = ADBDevice().shell(verify_cmd)
+        if not "OK" in r:
+            raise FBMSanapshotCreationError("Failed to create ")
+        logger.info(f"Snapshot created on device for package {pkg}: {dst}", flush=True)
+            
+
+
+@catchException("Error finalizing and merging FBM deltas")
+def finalize_and_merge(options: "Options"):
+    """Pull device fbms, compute deltas and merge deltas into PC core fbm.
+
+    Uses kea2.fbm_parser.FBMMerger.pull_and_merge_to_pc for each package.
+    """
+    from .fbm_parser import FBMMerger
+
+    merger = FBMMerger()
+    for pkg in options.packageNames:
+        logger.info(f"Finalizing FBM delta for package: {pkg}")
+        ok = merger.pull_and_merge_to_pc(pkg, device=options.serial, transport_id=options.transport_id)
+        if ok:
+            logger.info(f"Delta merge completed for package: {pkg}")
+        else:
+            logger.error(f"Delta merge reported failure for package: {pkg}")
+
+
+def merge_fbm(func):
+    """Decorator for KeaTestRunner.run: 
+    
+    Function: Merge FBM in multi-device test run to accelerate fastbot model training.
+
+    The decorator uses `create_device_snapshots` before the run and `finalize_and_merge` after run.
+    """
+    @functools.wraps(func)
+    def wrapper(self: "KeaTestRunner", *args, **kwargs):
+        # Pre-run snapshot creation
+        if self.options.download_fbm:
+            create_device_snapshots(self.options)
+
+        try:
+            return func(self, *args, **kwargs)
+        finally:
+            # Post-run finalize/merge
+            if self.options.upload_fbm:
+                finalize_and_merge(self.options)
+
+    return wrapper

{kea2_python-1.1.3b0 → kea2_python-1.1.3b2}/kea2/keaUtils.py

@@ -18,7 +18,6 @@ from unittest import main as unittest_main
 from dataclasses import dataclass, asdict, fields, is_dataclass
 from datetime import datetime
 from fnmatch import fnmatchcase
-
 import uiautomator2 as u2
 
 
@@ -33,6 +32,7 @@ from .fastbotManager import FastbotManager
 from .adbUtils import ADBDevice
 from .state import invariant, INVARIANT_MARKER
 from .result import KeaJsonResult, KeaTextTestResult
+from .fbm_plugin import merge_fbm
 
 logger = getLogger(__name__)
 hybrid_mode = ContextVar("hybrid_mode", default=False)
@@ -400,18 +400,11 @@ class KeaTestRunner(TextTestRunner, KeaOptionSetter, SetUpClassExtension):
         logger.info(f"Result file: {stamp_manager.result_file}")
         logger.info(f"Property execution info file: {stamp_manager.prop_exec_file}")
 
+    @merge_fbm
     def run(self, test):
 
-
-        # take device-side snapshots once at the beginning of the run
-        try:
-            self._copy_fbm()
-        except Exception as e:
-            logger.debug(f"Initial device snapshot failed: {e}")
-
         self.validateAndCollectProperties(test)
 
-
         if len(self.allProperties) == 0:
             logger.warning("No property has been found.")
 
@@ -557,18 +550,12 @@ class KeaTestRunner(TextTestRunner, KeaOptionSetter, SetUpClassExtension):
             print(f"Finish sending monkey events.", flush=True)
             log_watcher.close()
 
-        # After run: compute per-device deltas and merge into PC core
-        try:
-            self._finalize_and_merge_deltas()
-        except Exception as e:
-            logger.debug(f"Finalize delta merge failed: {e}")
 
         result.logSummary()
 
         if self.options.agent == "u2":
             self._generate_bug_report()
 
-        # self._upload_fbm()
 
         self.tearDown()
         return result
@@ -813,104 +800,6 @@ class KeaTestRunner(TextTestRunner, KeaOptionSetter, SetUpClassExtension):
             # Ignore exceptions in __del__ to avoid "Exception ignored" warnings
             pass
 
-
-    def _finalize_and_merge_deltas(self):
-        """Pull device fbms, compute deltas (snapshot->current) and merge deltas into PC core fbm.
-
-        This function iterates over configured packages and uses pull_and_merge_to_pc which
-        already implements snapshot-aware delta merging when a snapshot is present on device.
-        """
-        try:
-            from kea2.fbm_parser import FBMMerger
-        except Exception as e:
-            logger.debug(f"FBM merger unavailable for finalize: {e}")
-            return
-
-        merger = FBMMerger()
-        pkgs = getattr(self.options, 'packageNames', []) or []
-        for pkg in pkgs:
-            try:
-                logger.info(f"Finalizing FBM delta for package: {pkg}")
-                ok = merger.pull_and_merge_to_pc(pkg, device=self.options.serial,
-                                                 transport_id=self.options.transport_id)
-                if ok:
-                    logger.info(f"Delta merge completed for package: {pkg}")
-                else:
-                    logger.debug(f"Delta merge reported failure for package: {pkg}")
-            except Exception as e:
-                logger.debug(f"Error finalizing delta for {pkg}: {e}")
-
-
-    def _copy_fbm(self):
-        """If options.download_fbm is True, create an on-device snapshot for each package by copying
-        `/sdcard/fastbot_{pkg}.fbm` -> `/sdcard/fastbot_{pkg}.snapshot.fbm` using `adb shell cp`.
-
-        Behavior:
-        - Only runs if options.download_fbm is True.
-        - Tries `adb shell cp` up to `max_retries` times with backoff. Does NOT perform pull/push.
-        - Logs per-package success/failure and does not raise to avoid blocking startup.
-        """
-        # if not getattr(self.options, 'download_fbm', False):
-        #     return
-
-        try:
-            from kea2.adbUtils import adb_shell
-        except Exception:
-            try:
-                from adbUtils import adb_shell  # type: ignore
-            except Exception as e:
-                print(f"ADB utilities not available for creating device snapshot: {e}", flush=True)
-                return
-
-        import time
-        import random
-
-        pkgs = getattr(self.options, 'packageNames', []) or []
-        for pkg in pkgs:
-            src = f"/sdcard/fastbot_{pkg}.fbm"
-            dst = f"/sdcard/fastbot_{pkg}.snapshot.fbm"
-
-            # First check if the source FBM exists on device. If not, skip this package.
-            try:
-                # use a single-string shell command so adb runs: adb -s <dev> shell "test -f <src> && echo OK || echo NO"
-                check_src = adb_shell([f'test -f "{src}" && echo OK || echo NO'], device=self.options.serial, transport_id=self.options.transport_id)
-                if not (isinstance(check_src, str) and "OK" in check_src):
-                    print(f"Source FBM not found on device for package {pkg}: {src}. Skipping snapshot creation.", flush=True)
-                    continue
-            except Exception as e:
-                print(f"Failed to verify source FBM existence for {pkg}: {e}. Skipping.", flush=True)
-                continue
-
-            max_retries = 3
-            success = False
-            for attempt in range(1, max_retries + 1):
-                try:
-                    print(f"Attempt {attempt}: creating device snapshot: cp {src} {dst}", flush=True)
-                    adb_shell(["cp", src, dst], device=self.options.serial, transport_id=self.options.transport_id)
-
-                    # verify snapshot exists on device using a single-command form
-                    try:
-                        # verify snapshot exists on device using a single-string command (matches: adb shell "test -f ... && echo OK || echo NO")
-                        verify = adb_shell([f'test -f "{dst}" && echo OK || echo NO'], device=self.options.serial, transport_id=self.options.transport_id)
-                        if isinstance(verify, str) and "OK" in verify:
-                            print(f"Snapshot created on device for package {pkg}: {dst}", flush=True)
-                            success = True
-                            break
-                        else:
-                            print(f"Snapshot verify failed on attempt {attempt} for {pkg}: {verify}", flush=True)
-                    except Exception as ve:
-                        print(f"Verification command failed after cp attempt {attempt} for {pkg}: {ve}", flush=True)
-                except Exception as e:
-                    print(f"adb shell cp attempt {attempt} failed for {pkg}: {e}", flush=True)
-
-                # backoff before next attempt
-                sleep_time = min(5.0, 0.5 * (2 ** (attempt - 1))) + random.uniform(0, 0.1)
-                time.sleep(sleep_time)
-
-            if not success:
-                print(f"Giving up creating snapshot on device for {pkg} after {max_retries} attempts", flush=True)
-
-
 class HybridTestRunner(TextTestRunner, KeaOptionSetter):
 
     allTestCases: Dict[str, Tuple[TestCase, bool]]