Kea2-python 1.0.6b0__py3-none-any.whl

kea2/utils.py

@@ -0,0 +1,184 @@
+import os
+import logging
+import traceback
+import time
+
+from pathlib import Path
+from functools import wraps
+from typing import Callable, Dict, Optional, Union
+
+
+def singleton(cls):
+    _instance = {}
+
+    def inner():
+        if cls not in _instance:
+            _instance[cls] = cls()
+        return _instance[cls]
+    return inner
+
+
+class LoggingLevel:
+    level = logging.INFO
+    _instance: Optional["LoggingLevel"] = None  # 单例缓存
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def set_level(cls, level: int):
+        cls.level = level
+
+
+class DynamicLevelFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.levelno >= LoggingLevel.level
+
+
+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()
+            handler.setFormatter(logging.Formatter('[%(levelname)1s][%(asctime)s %(module)s:%(lineno)d pid:%(process)d] %(message)s'))
+            handler.setLevel(logging.NOTSET)
+            handler.addFilter(DynamicLevelFilter())
+            logger.addHandler(handler)
+            logger.setLevel(logging.DEBUG)
+            logger.propagate = False
+
+    enable_pretty_logging()
+    return logger
+
+
+logger = getLogger(__name__)
+
+
+
+
+@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
+    
+    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"):
+        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
+
+
+def loadFuncsFromFile(file_path: str) -> Dict[str, Callable]:
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"{file_path} not found.")
+
+    def __get_module():
+        import importlib.util
+        module_name = Path(file_path).stem
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod
+
+    mod = __get_module()
+
+    import inspect
+    funcs = dict()
+    for func_name, func in inspect.getmembers(mod, inspect.isfunction):
+        funcs[func_name] = func
+
+    return funcs

kea2/version_manager.py

@@ -0,0 +1,102 @@
+import os
+import json
+import shutil
+
+from pathlib import Path
+from packaging.version import Version
+from typing import List, Set, TypedDict
+from importlib.metadata import version
+
+from .utils import getLogger, getProjectRoot
+
+logger = getLogger(__name__)
+
+
+CompatibilityInfo = TypedDict('CompatibilityInfo', {
+    "name": str,
+    "description": str,
+    "from": str,
+    "to": str,
+})
+VersionInfo = TypedDict('VersionInfo', {
+    "compatibility infos": List[CompatibilityInfo],
+})
+
+
+def ls_files(dir_path: Path) -> Set[Path]:
+    """list all files in the directory"""
+    return set(f for f in dir_path.rglob('*') if f.is_file())
+
+
+def check_config_compatibility():
+    config_version_sanitizer = ConfigVersionSanitizer()
+    config_version_sanitizer.check_config_compatibility()
+    config_version_sanitizer.config_auto_update()
+
+
+def get_cur_version():
+    return version("Kea2-python")
+
+
+class ConfigVersionSanitizer:
+    def __init__(self):
+        self._version_infos = None
+        self._config_version = None
+        self.user_config_path = getProjectRoot() / "configs"
+        self.kea2_assets_path = Path(__file__).parent / "assets"
+        self.kea2_version = get_cur_version()
+
+    @property
+    def version_infos(self) -> VersionInfo:
+        if self._version_infos is None:
+            with open(self.kea2_assets_path / "config_version.json") as fp:
+                self._version_infos = json.load(fp)
+        return self._version_infos
+
+    @property
+    def config_version(self):
+        if self._config_version is not None:
+            return self._config_version
+
+        user_version_json = self.user_config_path / "version.json"
+        if not user_version_json.exists():
+            self._config_version = "0.3.6"
+        else:
+            with open(user_version_json) as fp:
+                self._config_version = json.load(fp)["version"]
+        return self._config_version
+
+    def check_config_compatibility(self):
+        """Check if the user config version is compatible with the current Kea2 version.""" 
+        update_infos = []
+        for info in self.version_infos["compatibility infos"]:
+            if Version(info["from"]) > Version(self.config_version):
+                update_infos.append(info)
+
+        if not update_infos:
+            return
+
+        logger.warning("Configuration update required! Please update your configuration files.")
+        logger.warning(f"Current kea2 version {self.kea2_version}. Current config version {self.config_version}.")
+        for info in update_infos:
+            logger.info(
+                f"Since version {info['from']}: {info['description']}"
+            )
+    
+    def config_auto_update(self):
+        self._copy_new_configs()
+    
+    def _copy_new_configs(self):
+        src = self.kea2_assets_path / "fastbot_configs"
+        dst = self.user_config_path
+        
+        src_files = set(os.listdir(src))
+        dst_files = set(os.listdir(dst))
+        
+        new_files = src_files - dst_files
+        
+        for file in new_files:
+            src_path = src / file
+            dst_path = dst / file
+            logger.info(f"Copying new config file: {file}")
+            shutil.copy2(src_path, dst_path)