ok-script 0.0.7__py3-none-any.whl

autohelper/capture/adb/vbox.py

@@ -0,0 +1,140 @@
+# https://github.com/ArknightsAutoHelper/ArknightsAutoHelper/blob/5a9284773b68e12012c338cce50cb732f6a3542c/automator/control/adb/targets/vbox.py
+
+import winreg
+from dataclasses import dataclass
+
+import adbutils
+import win32com.client
+
+from autohelper.capture.adb.targets import ADBControllerTarget
+from autohelper.logging.Logger import get_logger
+from autohelper.util import win32_process
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class VBoxClass:
+    clsid: str
+    vendor: str
+    tag: str
+
+
+@dataclass
+class VBoxSerever(VBoxClass):
+    path: str
+    pid: int = 0
+
+
+import ctypes
+
+vbox_clsids = [
+    VBoxClass('{20190809-47b9-4a1e-82b2-07ccd5323c3f}', 'LDPlayer', 'ld'),
+    VBoxClass('{20191216-47b9-4a1e-82b2-07ccd5323c3f}', 'LDPlayer9', 'ld9'),
+    VBoxClass('{88888888-47b9-4a1e-82b2-07ccd5323c3f}', 'Nox', 'nox'),
+    VBoxClass('{baf3f651-58d8-429d-97ad-2b5699b43567}', 'BlueStacks', 'bstk'),
+    VBoxClass('{b1a7a4f2-47b9-4a1e-82b2-07ccd5323c3a}', 'Memu', 'memu'),
+    VBoxClass('{81919390-a492-11e5-a837-0800200c9a66}', 'MuMu', 'mumu'),
+    VBoxClass('{23cd1535-edaa-4f21-a4ab-45d97fd1d58b}', 'MuMu 12',
+              'mumu 12'),
+    # ('{B1A7A4F2-47B9-4A1E-82B2-07CCD5323C3F}', 'Oracle', 'oracle'),  # nobody uses this
+]
+
+OpenProcess = ctypes.windll.kernel32.OpenProcess
+OpenProcess.argtypes = [ctypes.c_uint32, ctypes.c_bool, ctypes.c_uint32]
+OpenProcess.restype = ctypes.c_void_p
+PROCESS_QUERY_INFORMATION = 0x0400
+CloseHandle = ctypes.windll.kernel32.CloseHandle
+CloseHandle.argtypes = [ctypes.c_void_p]
+
+
+def get_server(clsid):
+    try:
+        with winreg.OpenKeyEx(winreg.HKEY_CLASSES_ROOT, 'CLSID\\%s\\LocalServer32' % clsid, 0,
+                              winreg.KEY_READ) as hkey:
+            value = winreg.QueryValue(hkey, None)
+            filename = value.strip('"')
+            return win32_process.get_final_path(filename)
+    except OSError:
+        return None
+
+
+# current process's privilege must equal to the target process's privilege, can raise a error if not
+def installed_emulator():
+    logger.debug('enumerating vbox targets')
+    vbox_servers: list[VBoxSerever] = []
+    for vboxcls in vbox_clsids:
+        server = get_server(vboxcls.clsid)
+        if server:
+            logger.debug(f"enumerating vbox {server}")
+            vbox_servers.append(VBoxSerever(vboxcls.clsid, vboxcls.vendor, vboxcls.tag, server))
+
+    logger.debug(f'installed VirtualBox servers: {vbox_servers}')
+
+    running_processes = {pid: win32_process.resolve_image_name(pid) for pid in win32_process.all_pids()}
+    # logger.debug(f'running processes: {running_processes}')
+    for pid, path in running_processes.items():
+        # logger.debug(f'running_processes: {pid, path}')
+        for vbox_server in vbox_servers:
+            if vbox_server.path == path:
+                vbox_server.pid = pid
+                logger.debug(f'found vbox server: {vbox_server} {pid, path}')
+                break
+    running_servers = [x for x in vbox_servers if x.pid]
+    # running_servers = [x for x in vbox_servers if x[3] in running_processes]
+
+    logger.debug(f'running VirtualBox servers: {running_servers}')
+    results = []
+    for server in running_servers:
+        logger.debug(f'checking {server}')
+        hproc = OpenProcess(PROCESS_QUERY_INFORMATION, False, server.pid)
+        if not hproc:
+            logger.debug(f'try OpenProcess failed for PID {server.pid}')
+            continue
+        CloseHandle(hproc)
+        logger.debug(f'checking hproc end {server}')
+        try:
+            client = win32com.client.Dispatch(server.clsid)
+            for machine in client.Machines:
+                machine_name = machine.Name
+                logger.debug(f'checking machine {machine_name}')
+                if not machine.State == 5:
+                    # machine is not running
+                    continue
+                for adapter_id in range(4):
+                    adapter = machine.GetNetworkAdapter(adapter_id)
+                    if adapter.Enabled and adapter.AttachmentType == 1:
+                        # adapter is enabled and attached to per-machine NAT
+                        forwards = adapter.NatEngine.Redirects
+                        for forward in forwards:
+                            rule_name, proto, host, port, guest_host, guest_port = forward.split(',', 5)
+                            if proto == '1' and guest_port == '5555':
+                                address = f'127.0.0.1:{port}'
+                                identifier = f'vbox:{server.tag}:{machine_name}'
+                                logger.debug(
+                                    f'adb_server, None, {server.vendor}: {machine_name}, {address}, 2, 1, override_identifier={identifier}')
+                                results.append(
+                                    ADBControllerTarget(None, f'{server.vendor}',
+                                                        address, 2, 1, override_identifier=identifier,
+                                                        preload_device_info={'emulator_hypervisor': 'vbox'}))
+            logger.debug(f'try checking {server}')
+        except Exception as e:
+            logger.error(f'failed to check server :{server} {e}', e)
+    return results
+
+
+def _main():
+    logger.config({'debug': True})
+    adb = adbutils.AdbClient(host="127.0.0.1", port=5037)
+    for x in installed_emulator():
+        logger.debug(f'installed emulators {x}')
+        adb.connect(x.adb_address)
+
+    logger.debug(adb.device_list())
+    for device in adb.device_list():
+        logger.debug(device.shell('settings get secure android_id'))
+        logger.debug(f'{device.info}')
+
+
+if __name__ == '__main__':
+    _main()

autohelper/capture/windows/WindowsGraphicsCaptureMethod.py

@@ -0,0 +1,228 @@
+# original https://github.com/dantmnf & https://github.com/hakaboom/winAuto
+import ctypes
+import ctypes.wintypes
+import time
+
+import numpy as np
+from typing_extensions import override
+
+from autohelper.capture.BaseCaptureMethod import BaseCaptureMethod
+from autohelper.capture.HwndWindow import HwndWindow
+from autohelper.capture.windows import d3d11
+from autohelper.capture.windows.utils import WINDOWS_BUILD_NUMBER
+from autohelper.logging.Logger import get_logger
+from autohelper.rotypes import IInspectable
+from autohelper.rotypes.Windows.Foundation import TypedEventHandler
+from autohelper.rotypes.Windows.Graphics.Capture import Direct3D11CaptureFramePool, IGraphicsCaptureItemInterop, \
+    IGraphicsCaptureItem, GraphicsCaptureItem
+from autohelper.rotypes.Windows.Graphics.DirectX import DirectXPixelFormat
+from autohelper.rotypes.Windows.Graphics.DirectX.Direct3D11 import IDirect3DDevice, \
+    CreateDirect3D11DeviceFromDXGIDevice, \
+    IDirect3DDxgiInterfaceAccess
+from autohelper.rotypes.roapi import GetActivationFactory
+
+PBYTE = ctypes.POINTER(ctypes.c_ubyte)
+WGC_NO_BORDER_MIN_BUILD = 20348
+
+logger = get_logger(__name__)
+
+
+class WindowsGraphicsCaptureMethod(BaseCaptureMethod):
+    name = "Windows Graphics Capture"
+    description = "fast, most compatible, capped at 60fps"
+    last_frame = None
+    last_frame_time = 0
+    hwnd_window: HwndWindow = None
+    frame_pool = None
+    item = None
+    session = None
+    cputex = None
+
+    def __init__(self, hwnd_window: HwndWindow):
+        super().__init__()
+        self.hwnd_window = hwnd_window
+
+    def frame_arrived_callback(self, x, y):
+        try:
+            frame = self.frame_pool.TryGetNextFrame()
+        except Exception as e:
+            logger.error(f"TryGetNextFrame error {e}")
+            self.close()
+            return
+        if not frame:
+            return
+        self.last_frame_time = time.time()
+        img = None
+        with frame:
+            need_reset_framepool = False
+            need_reset_device = False
+            if frame.ContentSize.Width != self.last_size.Width or frame.ContentSize.Height != self.last_size.Height:
+                # print('size changed')
+                need_reset_framepool = True
+                self.last_size = frame.ContentSize
+
+            if need_reset_framepool:
+                self.reset_framepool(frame.ContentSize)
+                return
+            tex = None
+
+            cputex = None
+            try:
+                tex = frame.Surface.astype(IDirect3DDxgiInterfaceAccess).GetInterface(
+                    d3d11.ID3D11Texture2D.GUID).astype(d3d11.ID3D11Texture2D)
+                desc = tex.GetDesc()
+                desc2 = d3d11.D3D11_TEXTURE2D_DESC()
+                desc2.Width = desc.Width
+                desc2.Height = desc.Height
+                desc2.MipLevels = desc.MipLevels
+                desc2.ArraySize = desc.ArraySize
+                desc2.Format = desc.Format
+                desc2.SampleDesc = desc.SampleDesc
+                desc2.Usage = d3d11.D3D11_USAGE_STAGING
+                desc2.CPUAccessFlags = d3d11.D3D11_CPU_ACCESS_READ
+                desc2.BindFlags = 0
+                desc2.MiscFlags = 0
+                cputex = self.dxdevice.CreateTexture2D(ctypes.byref(desc2), None)
+                self.immediatedc.CopyResource(cputex, tex)
+                mapinfo = self.immediatedc.Map(cputex, 0, d3d11.D3D11_MAP_READ, 0)
+                img = np.ctypeslib.as_array(ctypes.cast(mapinfo.pData, PBYTE),
+                                            (desc.Height, mapinfo.RowPitch // 4, 4))[
+                      :, :desc.Width].copy()
+                self.immediatedc.Unmap(cputex, 0)
+            except OSError as e:
+                if e.winerror == d3d11.DXGI_ERROR_DEVICE_REMOVED or e.winerror == d3d11.DXGI_ERROR_DEVICE_RESET:
+                    need_reset_framepool = True
+                    need_reset_device = True
+                else:
+                    raise
+            finally:
+                if tex is not None:
+                    tex.Release()
+                if cputex is not None:
+                    cputex.Release()
+            if need_reset_framepool:
+                self.reset_framepool(frame.ContentSize, need_reset_device)
+                return self.get_frame()
+        self.last_frame = img
+
+    def start_or_stop(self, capture_cursor=False):
+        if self.hwnd_window.exists and self.frame_pool is None:
+            logger.info('init windows capture')
+            self.rtdevice = IDirect3DDevice()
+            self.dxdevice = d3d11.ID3D11Device()
+            self.immediatedc = d3d11.ID3D11DeviceContext()
+            self.create_device()
+            interop = GetActivationFactory('Windows.Graphics.Capture.GraphicsCaptureItem').astype(
+                IGraphicsCaptureItemInterop)
+            item = interop.CreateForWindow(self.hwnd_window.hwnd, IGraphicsCaptureItem.GUID)
+            self.item = item
+            self.last_size = item.Size
+            delegate = TypedEventHandler(GraphicsCaptureItem, IInspectable).delegate(
+                self.close)
+            self.evtoken = item.add_Closed(delegate)
+            self.frame_pool = Direct3D11CaptureFramePool.CreateFreeThreaded(self.rtdevice,
+                                                                            DirectXPixelFormat.B8G8R8A8UIntNormalized,
+                                                                            1, item.Size)
+            self.session = self.frame_pool.CreateCaptureSession(item)
+            pool = self.frame_pool
+            pool.add_FrameArrived(
+                TypedEventHandler(Direct3D11CaptureFramePool, IInspectable).delegate(
+                    self.frame_arrived_callback))
+            self.session.IsCursorCaptureEnabled = capture_cursor
+            if WINDOWS_BUILD_NUMBER >= WGC_NO_BORDER_MIN_BUILD:
+                self.session.IsBorderRequired = False
+            self.session.StartCapture()
+        elif not self.hwnd_window.exists and self.frame_pool is not None:
+            self.close()
+        return self.hwnd_window.exists
+
+    def create_device(self):
+        d3d11.D3D11CreateDevice(
+            None,
+            d3d11.D3D_DRIVER_TYPE_HARDWARE,
+            None,
+            d3d11.D3D11_CREATE_DEVICE_BGRA_SUPPORT,
+            None,
+            0,
+            d3d11.D3D11_SDK_VERSION,
+            ctypes.byref(self.dxdevice),
+            None,
+            ctypes.byref(self.immediatedc)
+        )
+        self.rtdevice = CreateDirect3D11DeviceFromDXGIDevice(self.dxdevice)
+        self.evtoken = None
+
+    @override
+    def close(self):
+        logger.info('destroy windows capture')
+        if self.frame_pool is not None:
+            self.frame_pool.Close()
+            self.frame_pool = None
+        if self.session is not None:
+            self.session.Close()  # E_UNEXPECTED ???
+            self.session = None
+        self.item = None
+        self.rtdevice.Release()
+        self.dxdevice.Release()
+        if self.cputex:
+            self.cputex.Release()
+
+    def get_frame(self):
+        if self.start_or_stop():
+            frame = self.last_frame
+            self.last_frame = None
+            latency = time.time() - self.last_frame_time
+            self.last_frame_time = time.time()
+            if latency > 1:
+                logger.warning(f"latency too large return None frame: {latency}")
+                return None
+            if frame is not None:
+                x, y = self.hwnd_window.get_top_left_frame_offset()
+                if x > 0 or y > 0:
+                    frame = crop_image(frame, x, y)
+
+            if frame is not None:
+                new_height, new_width = frame.shape[:2]
+                if new_width <= 0 or new_width <= 0:
+                    logger.warning(f"get_frame size <=0 {new_width}x{new_height}")
+                    frame = None
+                else:
+                    self.width = new_width
+                    self.height = new_height
+                    if frame.shape[2] == 4:
+                        frame = frame[:, :, :3]
+            return frame
+
+    def reset_framepool(self, size, reset_device=False):
+        if reset_device:
+            self.create_device()
+        self.frame_pool.Recreate(self.rtdevice,
+                                 DirectXPixelFormat.B8G8R8A8UIntNormalized, 1, size)
+
+    def get_abs_cords(self, x, y):
+        return self.hwnd_window.get_abs_cords(x, y)
+
+    def clickable(self):
+        return self.hwnd_window.visible
+
+
+def crop_image(image, border, title_height):
+    # Load the image
+    # Image dimensions
+    height, width = image.shape[:2]
+
+    # Calculate the coordinates for the bottom-right corner
+    x2 = width - border
+    y2 = height - border
+
+    # Crop the image
+    cropped_image = image[title_height:y2, border:x2]
+
+    # print(f"cropped image: {title_height}-{y2}, {border}-{x2} {cropped_image.shape}")
+    #
+    # cv2.imshow('Image Window', cropped_image)
+    #
+    # # Wait for any key to be pressed before closing the window
+    # cv2.waitKey(0)
+
+    return cropped_image

autohelper/capture/windows/d3d11.py

@@ -0,0 +1,74 @@
+import ctypes.wintypes
+
+from autohelper.rotypes import IUnknown
+from autohelper.rotypes import idldsl
+
+D3D11_SDK_VERSION = 7
+D3D_DRIVER_TYPE_HARDWARE = 1
+D3D11_CREATE_DEVICE_BGRA_SUPPORT = 0x20
+D3D11_USAGE_STAGING = 3
+D3D11_CPU_ACCESS_READ = 0x20000
+D3D11_MAP_READ = 1
+DXGI_ERROR_DEVICE_REMOVED = 0x887A0005
+DXGI_ERROR_DEVICE_RESET = 0x887A0007
+
+
+class DXGI_SAMPLE_DESC(ctypes.Structure):
+    _fields_ = [
+        ('Count', ctypes.wintypes.UINT),
+        ('Quality', ctypes.wintypes.UINT)
+    ]
+
+
+class D3D11_TEXTURE2D_DESC(ctypes.Structure):
+    _fields_ = [
+        ('Width', ctypes.wintypes.UINT),
+        ('Height', ctypes.wintypes.UINT),
+        ('MipLevels', ctypes.wintypes.UINT),
+        ('ArraySize', ctypes.wintypes.UINT),
+        ('Format', ctypes.wintypes.UINT),
+        ('SampleDesc', DXGI_SAMPLE_DESC),
+        ('Usage', ctypes.wintypes.UINT),
+        ('BindFlags', ctypes.wintypes.UINT),
+        ('CPUAccessFlags', ctypes.wintypes.UINT),
+        ('MiscFlags', ctypes.wintypes.UINT),
+    ]
+
+
+class D3D11_MAPPED_SUBRESOURCE(ctypes.Structure):
+    _fields_ = [
+        ('pData', ctypes.c_void_p),
+        ('RowPitch', ctypes.wintypes.UINT),
+        ('DepthPitch', ctypes.wintypes.UINT)
+    ]
+
+
+@idldsl.GUID('db6f6ddb-ac77-4e88-8253-819df9bbf140')
+class ID3D11Device(IUnknown):
+    pass
+
+
+@idldsl.GUID('6f15aaf2-d208-4e89-9ab4-489535d34f9c')
+class ID3D11Texture2D(IUnknown):
+    pass
+
+
+@idldsl.GUID('c0bfa96c-e089-44fb-8eaf-26f8796190da')
+class ID3D11DeviceContext(IUnknown):
+    pass
+
+
+idldsl.define_winrt_com_method(ID3D11Device, 'CreateTexture2D', ctypes.POINTER(D3D11_TEXTURE2D_DESC), ctypes.c_void_p,
+                               retval=ID3D11Texture2D, vtbl=5)
+idldsl.define_winrt_com_method(ID3D11Device, 'GetImmediateContext', retval=ID3D11DeviceContext, vtbl=40)
+# idldsl.define_winrt_com_method(ID3D11Texture2D, 'GetDevice', retval=ID3D11Texture2D, vtbl=3)
+idldsl.define_winrt_com_method(ID3D11Texture2D, 'GetDesc', retval=D3D11_TEXTURE2D_DESC, vtbl=10)
+idldsl.define_winrt_com_method(ID3D11DeviceContext, 'Map', IUnknown, ctypes.c_uint, ctypes.c_int, ctypes.c_uint,
+                               retval=D3D11_MAPPED_SUBRESOURCE, vtbl=14)
+idldsl.define_winrt_com_method(ID3D11DeviceContext, 'Unmap', IUnknown, ctypes.c_uint, vtbl=15)
+idldsl.define_winrt_com_method(ID3D11DeviceContext, 'CopyResource', IUnknown, IUnknown, vtbl=47)
+
+D3D11CreateDevice = ctypes.oledll.d3d11.D3D11CreateDevice
+D3D11CreateDevice.argtypes = (
+    IUnknown, ctypes.c_int, ctypes.c_void_p, ctypes.wintypes.UINT, ctypes.c_void_p, ctypes.c_uint, ctypes.c_uint,
+    ID3D11Device, ctypes.c_void_p, ID3D11DeviceContext)

autohelper/capture/windows/utils.py

@@ -0,0 +1,149 @@
+import asyncio
+import ctypes
+import ctypes.wintypes
+import os
+import sys
+from collections.abc import Callable, Iterable
+from enum import IntEnum
+from itertools import chain
+from platform import version
+from threading import Thread
+from typing import TYPE_CHECKING, Any, TypeGuard, TypeVar
+
+import numpy as np
+import win32gui
+import win32ui
+
+if TYPE_CHECKING:
+    # Source does not exist, keep this under TYPE_CHECKING
+    from _win32typing import PyCDC  # pyright: ignore[reportMissingModuleSource]
+
+T = TypeVar("T")
+
+ONE_SECOND = 1000
+"""1000 milliseconds in 1 second"""
+DWMWA_EXTENDED_FRAME_BOUNDS = 9
+MAXBYTE = 255
+BGR_CHANNEL_COUNT = 3
+"""How many channels in a BGR image"""
+BGRA_CHANNEL_COUNT = 4
+"""How many channels in a BGRA image"""
+
+
+class ImageShape(IntEnum):
+    Y = 0
+    X = 1
+    Channels = 2
+
+
+class ColorChannel(IntEnum):
+    Blue = 0
+    Green = 1
+    Red = 2
+    Alpha = 3
+
+
+def decimal(value: float):
+    # Using ljust instead of :2f because of python float rounding errors
+    return f"{int(value * 100) / 100}".ljust(4, "0")
+
+
+def is_digit(value: str | int | None):
+    """Checks if `value` is a single-digit string from 0-9."""
+    if value is None:
+        return False
+    try:
+        return 0 <= int(value) <= 9  # noqa: PLR2004
+    except (ValueError, TypeError):
+        return False
+
+
+def is_valid_image(image: np.ndarray | None) -> TypeGuard[np.ndarray]:
+    return image is not None and bool(image.size)
+
+
+def is_valid_hwnd(hwnd: int):
+    """Validate the hwnd points to a valid window and not the desktop or whatever window obtained with `""`."""
+    if not hwnd:
+        return False
+    if sys.platform == "win32":
+        return bool(win32gui.IsWindow(hwnd) and win32gui.GetWindowText(hwnd))
+    return True
+
+
+def first(iterable: Iterable[T]) -> T:
+    """@return: The first element of a collection. Dictionaries will return the first key."""
+    return next(iter(iterable))
+
+
+def try_delete_dc(dc: "PyCDC"):
+    try:
+        dc.DeleteDC()
+    except win32ui.error:
+        pass
+
+
+def get_window_bounds(hwnd: int) -> tuple[int, int, int, int]:
+    extended_frame_bounds = ctypes.wintypes.RECT()
+    ctypes.windll.dwmapi.DwmGetWindowAttribute(
+        hwnd,
+        DWMWA_EXTENDED_FRAME_BOUNDS,
+        ctypes.byref(extended_frame_bounds),
+        ctypes.sizeof(extended_frame_bounds),
+    )
+
+    window_rect = win32gui.GetWindowRect(hwnd)
+    window_left_bounds = extended_frame_bounds.left - window_rect[0]
+    window_top_bounds = extended_frame_bounds.top - window_rect[1]
+    window_width = extended_frame_bounds.right - extended_frame_bounds.left
+    window_height = extended_frame_bounds.bottom - extended_frame_bounds.top
+    return window_left_bounds, window_top_bounds, window_width, window_height
+
+
+def open_file(file_path: str | bytes | os.PathLike[str] | os.PathLike[bytes]):
+    os.startfile(file_path)  # noqa: S606
+
+
+def get_or_create_eventloop():
+    try:
+        return asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return asyncio.get_event_loop()
+
+
+def fire_and_forget(func: Callable[..., Any]):
+    """
+    Runs synchronous function asynchronously without waiting for a response.
+
+    Uses threads on Windows because ~~`RuntimeError: There is no current event loop in thread 'MainThread'.`~~
+    Because maybe asyncio has issues. Unsure. See alpha.5 and https://github.com/Avasam/AutoSplit/issues/36
+
+    Uses asyncio on Linux because of a `Segmentation fault (core dumped)`
+    """
+
+    def wrapped(*args: Any, **kwargs: Any):
+        if sys.platform == "win32":
+            thread = Thread(target=func, args=args, kwargs=kwargs)
+            thread.start()
+            return thread
+        return get_or_create_eventloop().run_in_executor(None, func, *args, *kwargs)
+
+    return wrapped
+
+
+def flatten(nested_iterable: Iterable[Iterable[T]]) -> chain[T]:
+    return chain.from_iterable(nested_iterable)
+
+
+# Environment specifics
+WINDOWS_BUILD_NUMBER = int(version().split(".")[-1]) if sys.platform == "win32" else -1
+FIRST_WIN_11_BUILD = 22000
+"""AutoSplit Version number"""
+WGC_MIN_BUILD = 17134
+"""https://docs.microsoft.com/en-us/uwp/api/windows.graphics.capture.graphicscapturepicker#applies-to"""
+FROZEN = hasattr(sys, "frozen")
+"""Running from build made by PyInstaller"""
+auto_split_directory = os.path.dirname(sys.executable if FROZEN else os.path.abspath(__file__))
+"""The directory of either the AutoSplit executable or AutoSplit.py"""

autohelper/capture/windows/window.py

@@ -0,0 +1,36 @@
+import ctypes
+import ctypes.wintypes
+
+import win32gui
+
+user32 = ctypes.WinDLL('user32', use_last_error=True)
+
+DWMWA_EXTENDED_FRAME_BOUNDS = 9
+
+
+def is_window_minimized(hWnd):
+    return user32.IsIconic(hWnd) != 0
+
+
+def get_window_bounds(hwnd):
+    extended_frame_bounds = ctypes.wintypes.RECT()
+    ctypes.windll.dwmapi.DwmGetWindowAttribute(
+        hwnd,
+        DWMWA_EXTENDED_FRAME_BOUNDS,
+        ctypes.byref(extended_frame_bounds),
+        ctypes.sizeof(extended_frame_bounds),
+    )
+    scaling = user32.GetDpiForWindow(hwnd) / 96
+    client_x, client_y, client_width, client_height = win32gui.GetClientRect(hwnd)
+    client_width = int(client_width / scaling)
+    client_height = int(client_height / scaling)
+    window_width = int((extended_frame_bounds.right - extended_frame_bounds.left) / scaling)
+    window_height = int((extended_frame_bounds.bottom - extended_frame_bounds.top) / scaling)
+    border = int((window_width - client_width) / 2)
+    title = window_height - client_height - border
+    return int(extended_frame_bounds.left / scaling), int(
+        extended_frame_bounds.top / scaling), border, title, client_width, client_height, scaling
+
+
+def is_foreground_window(hwnd):
+    return win32gui.IsWindowVisible(hwnd) and win32gui.GetForegroundWindow() == hwnd

autohelper/color/Color.py

@@ -0,0 +1,41 @@
+import cv2
+
+black_color = {
+    'r': (0, 0),  # Red range
+    'g': (0, 0),  # Green range
+    'b': (0, 0)  # Blue range
+}
+
+white_color = {
+    'r': (255, 255),  # Red range
+    'g': (255, 255),  # Green range
+    'b': (255, 255)  # Blue range
+}
+
+
+def calculate_color_percentage(image, color_ranges, box=None):
+    # Check if the ROI is within the image bounds
+    if box is not None:
+        if (box.x >= 0 and box.y >= 0 and
+                box.x + box.width <= image.shape[1] and  # image.shape[1] is the width of the image
+                box.y + box.height <= image.shape[0]):  # image.shape[0] is the height of the image
+
+            # Extract the region of interest (ROI) using slicing
+
+            image = image[box.y:box.y + box.height, box.x:box.x + box.width, :3]
+        else:
+            # Return some error value or raise an exception
+            # For example, return 0 or None
+            return 0  # or None, or raise an exception
+    else:
+        image = image[:, :, :3]
+    # Create a mask for the pixels within the desired color range
+    mask = cv2.inRange(image,
+                       (color_ranges['b'][0], color_ranges['g'][0], color_ranges['r'][0]),
+                       (color_ranges['b'][1], color_ranges['g'][1], color_ranges['r'][1]))
+
+    # Calculate the percentage of pixels within the color range
+    target_pixels = cv2.countNonZero(mask)
+    total_pixels = image.size / 3  # Divide by 3 for an RGB image
+    percentage = target_pixels / total_pixels
+    return percentage