ok-script 0.0.7__py3-none-any.whl

autohelper/rotypes/idldsl.py

@@ -0,0 +1,272 @@
+from _ctypes import _SimpleCData
+from functools import lru_cache
+import enum
+
+from . import roapi
+from .types import *
+
+class CtypesEnum(enum.IntEnum):
+    """A ctypes-compatible IntEnum superclass."""
+    @classmethod
+    def from_param(cls, obj):
+        return int(obj)
+
+
+def STDMETHOD(index, name, *argtypes):
+    proto = WINFUNCTYPE(check_hresult, *argtypes)
+    func = proto(index, name)
+    return func
+
+
+def define_winrt_com_method(interface, name, *argtypes, retval=None, propget=None, propput=None, vtbl: int = next):
+    if vtbl is next:
+        vtbl = interface._vtblend + 1
+    if getattr(interface, '_method_defs', None) is None:
+        setattr(interface, '_method_defs', [])
+    if interface._method_defs is getattr(interface.__mro__[1], '_method_defs', None):
+        setattr(interface, '_method_defs', [])
+    if retval is not None:
+        comfunc = STDMETHOD(vtbl, name, *argtypes, POINTER(retval))
+        if retval.__mro__[1] is _SimpleCData:  # if return type is primitive type
+            def func(this, *args, **kwargs):
+                obj = this.astype(interface)
+                result = retval()
+                comfunc(obj, *args, byref(result), **kwargs)
+                return result.value
+        else:
+            def func(this, *args, **kwargs):
+                obj = this.astype(interface)
+                result = _new_rtobj(retval)
+                comfunc(obj, *args, byref(result), **kwargs)
+                return result
+        interface._method_defs.append((vtbl, name, comfunc))
+        setattr(interface, '_' + name, comfunc)
+        setattr(interface, name, func)
+    elif propget is not None:  # name = "get_Something"
+        comgetter = STDMETHOD(vtbl, name, *argtypes, POINTER(propget))
+        setattr(interface, name, comgetter)
+        interface._method_defs.append((vtbl, name, comgetter))
+        if name.startswith('get_'):
+            propname = name[4:]
+            if propname in interface.__dict__:
+                setter = interface.__dict__[propname].fset
+            else:
+                setter = None
+
+            if propget.__mro__[1] is _SimpleCData:  # if return type is primitive type
+                def getter(this, *args, **kwargs):
+                    obj = this.astype(interface)
+                    result = propget()
+                    comgetter(obj, *args, byref(result), **kwargs)
+                    return result.value
+            else:
+                def getter(this, *args, **kwargs):
+                    obj = this.astype(interface)
+                    result = _new_rtobj(propget)
+                    comgetter(obj, *args, byref(result), **kwargs)
+                    return result
+            setattr(interface, propname, property(getter, setter))
+
+    elif propput is not None:  # name = 'put_Something'
+        comsetter = STDMETHOD(vtbl, name, *argtypes, propput)
+        interface._method_defs.append((vtbl, name, comsetter))
+        setattr(interface, name, comsetter)
+        if name.startswith('put_'):
+            propname = name[4:]
+            if propname in interface.__dict__:
+                getter = interface.__dict__[propname].fget
+            else:
+                getter = None
+
+            def setter(this, *args, **kwargs):
+                obj = this.astype(interface)
+                comsetter(obj, *args, **kwargs)
+
+            setattr(interface, propname, property(getter, setter))
+    else:
+        comfunc = STDMETHOD(vtbl, name, *argtypes)
+
+        def func(this, *args, **kwargs):
+            obj = this.astype(interface)
+            comfunc(obj, *args, **kwargs)
+
+        interface._method_defs.append((vtbl, name, comfunc))
+        setattr(interface, name, funcwrap(func))
+
+    if vtbl > interface._vtblend:
+        interface._vtblend = vtbl
+
+
+class classproperty(property):
+    def __get__(self, obj, type_):
+        return self.fget.__get__(None, type_)()
+
+    def __set__(self, obj, value):
+        cls = type(obj)
+        return self.fset.__get__(None, cls)(value)
+
+
+def _static_propget(interface, propname):
+    def getter(cls):
+        statics = roapi.GetActivationFactory(cls._runtimeclass_name, interface)
+        return getattr(statics, propname)
+
+    return classproperty(classmethod(getter))
+
+
+def _static_method(interface, methodname):
+    def func(cls, *args, **kwargs):
+        statics = roapi.GetActivationFactory(cls._runtimeclass_name, interface)
+        return getattr(statics, methodname)(*args, **kwargs)
+
+    return classmethod(func)
+
+
+def funcwrap(f):
+    return lambda *args, **kw: f(*args, **kw)
+
+
+def _non_activatable_init(self):
+    raise NotImplementedError('non-activatable runtime class ' + self._runtimeclass_name)
+
+
+_predefined_sigs = {
+    c_uint8: 'u1',
+    c_int32: 'i4',
+    c_uint32: 'u4',
+    c_int64: 'i8',
+    c_uint64: 'u8',
+    c_float: 'f4',
+    c_double: 'f8',
+    c_bool: 'b1',
+    str: 'string',
+    'char16': 'c2',
+    GUID: 'g16',
+}
+
+
+def _runtimeclass_signature(classname, default_iid):
+    return 'rc(%s;{%s})' % (classname, str(default_iid).lower())
+
+
+def _get_type_signature(clazz):
+    if hasattr(clazz, '_signature'):
+        return clazz._signature
+    elif isruntimeclass(clazz):
+        return _runtimeclass_signature(clazz._runtimeclass_name, clazz.__mro__[2].GUID)
+    elif hasattr(clazz, 'GUID'):
+        return '{%s}' % str(clazz.GUID).lower()
+    elif clazz in _predefined_sigs:
+        return _predefined_sigs[clazz]
+    else:
+        raise TypeError('no signature for type', clazz)
+
+
+_runtimeclass_registry = {}
+
+class runtimeclass:
+    def __init_subclass__(cls):
+        mod1 = cls.__module__.split('.')
+        mod2 = __name__.split('.')
+        i = 0
+        for i in range(min(len(mod1), len(mod2))):
+            if mod1[i] != mod2[i]:
+                break
+        name = mod1[i:]
+        name.append(cls.__name__)
+        clsname = '.'.join(name)
+        cls._runtimeclass_name = clsname
+        _runtimeclass_registry[clsname] = cls
+
+
+def isruntimeclass(clazz):
+    return clazz.__mro__[1] is runtimeclass
+
+
+def _new_rtobj(clazz):
+    if isruntimeclass(clazz):  # is a runtimeclass
+        return clazz.__mro__[2].__new__(clazz)
+    return clazz()
+
+
+def generics_cache(func):
+    def wrapped(*types):
+        if types in wrapped.known_types:
+            return wrapped.known_types[types]
+        return func(*types)
+
+    wrapped.known_types = {}
+    return wrapped
+
+
+def _sigoctets_to_uuid(octets):
+    import hashlib
+    digest = hashlib.sha1()
+    digest.update(octets)
+    uuidbytes = bytearray(digest.digest()[:16])
+    octet6 = uuidbytes[6]
+    octet6 = (octet6 & 0b00001111) | 0b01010000
+    uuidbytes[6] = octet6
+    octet8 = uuidbytes[8]
+    octet8 = (octet8 & 0b00111111) | 0b10000000
+    uuidbytes[8] = octet8
+    return '%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x' % tuple(uuidbytes)
+
+
+@lru_cache()
+def generate_parameterized_attrs(piid, *generics):
+    newsig = 'pinterface({%s};%s)' % (piid, ';'.join(map(_get_type_signature, generics)))
+    sigoctets = b'\x11\xF4z\xD5{sB\xC0\xAB\xAE\x87\x8B\x1E\x16\xAD\xEE' + newsig.encode('utf-8')
+    guid = _sigoctets_to_uuid(sigoctets)
+    return {'IID': guid, '_signature': newsig, '_typeparam': generics}
+
+
+def fqn(t):
+    return t.__qualname__
+
+
+def pinterface_type(name, piid, typeparams, bases):
+    attrs = generate_parameterized_attrs(piid, *typeparams)
+    cls = type('%s(%s)' % (name, ','.join(map(fqn, typeparams))), bases, attrs)
+    return cls
+
+
+def define_winrt_com_delegate(cls, *argtypes, retval=None):
+    from . import delegate
+    if retval is not None:
+        define_winrt_com_method(cls, 'Invoke', *argtypes, POINTER(retval), vtbl=3)
+    else:
+        define_winrt_com_method(cls, 'Invoke', *argtypes, vtbl=3)
+    cls._funcproto = delegate.proto(cls, *argtypes, retval=retval)
+
+# def runtimeclass2(cls: type):
+#     clsname = getattr(cls, '_runtimeclss_name_', None)
+#     if clsname is None:
+#         nameparts = cls.__qualname__.split('.')
+#         refparts = __name__.split('.')
+#         for i in range(min(len(nameparts), len(refparts))):
+#                 if nameparts[i] != refparts[i]:
+#                     break
+#         clsname = '.'.join(nameparts[i:])
+#     props = {'_runtimeclass_name': clsname}
+#     bases = [runtimeclass]
+#     if (default := getattr(cls, '_default_', None)) is not None:
+#         bases.append(default)
+#     interfaces = getattr(cls, '_default_', ())
+#     bases.extend(interfaces)
+#     statics = getattr(cls, '_static_', ())
+#     for static_intf in statics:
+#         static_intf # TODO
+#     newcls = type(clsname, tuple(bases), props)
+#     return newcls
+
+def runtimeclass_add_statics(cls, interface):
+    methods = [x[1] for x in interface._method_defs]
+    clsname = cls._runtimeclass_name
+    statics = roapi.GetActivationFactory(clsname, interface)
+    for method in methods:
+        wrapped_method = getattr(statics, method)
+        def wrapper(*args, **kwargs):
+            return wrapped_method(*args, **kwargs)
+        setattr(cls, method, staticmethod(wrapper))
+        

autohelper/rotypes/inspectable.py

@@ -0,0 +1,79 @@
+from .idldsl import define_winrt_com_method, funcwrap, _new_rtobj
+from .winstring import HSTRING
+from .types import *
+
+CoTaskMemFree = windll.ole32.CoTaskMemFree
+CoTaskMemFree.argtypes = (c_void_p,)
+
+# unknwn
+@GUID('00000000-0000-0000-C000-000000000046')
+class IUnknown(c_void_p):
+    _method_defs = [
+        (0, 'QueryInterface', WINFUNCTYPE(check_hresult, REFGUID, VOIDPP)(0, "QueryInterface")),
+        (1, 'AddRef', WINFUNCTYPE(ULONG)(1, "AddRef")),
+        (2, 'Release', WINFUNCTYPE(ULONG)(2, "Release"))
+    ]
+    QueryInterface = funcwrap(_method_defs[0][2])
+    _AddRef = funcwrap(_method_defs[1][2])
+    _Release = funcwrap(_method_defs[2][2])
+    _vtblend = 2
+
+    def _detach(self):
+        newptr = cast(self, c_void_p)
+        self.value = None
+        return newptr
+
+    def Release(self):
+        if self.value is not None:
+            self._Release()
+            self.value = None
+
+    def __del__(self):
+        self.Release()
+
+    def astype(self, interface_type):
+        iid = interface_type.GUID
+        obj = _new_rtobj(interface_type)
+        self.QueryInterface(byref(iid), byref(obj))
+        return obj
+
+    def __init_subclass__(cls):
+        cls._method_defs = []
+
+
+# inspectable
+class TrustLevel:
+    _enum_type_ = INT
+    BaseTrust = 0
+    PartialTrust = 1
+    FullTrust = 2
+
+@GUID('AF86E2E0-B12D-4c6a-9C5A-D7AA65101E90')
+class IInspectable(IUnknown):
+    def __class_getitem__(cls, name):
+        return cls
+    def __init_subclass__(cls, requires=()):
+        super().__init_subclass__()
+
+    def GetIids(self):
+        size = ULONG()
+        ptr = REFGUID()
+        self._GetIids(byref(size), byref(ptr))
+        result = [GUID(str(ptr[i])) for i in range(size.value)]
+        CoTaskMemFree(ptr)
+        return result
+
+
+
+define_winrt_com_method(IInspectable, '_GetIids', POINTER(ULONG), POINTER(REFGUID), vtbl=3)
+define_winrt_com_method(IInspectable, 'GetRuntimeClassName', retval=HSTRING, vtbl=4)
+define_winrt_com_method(IInspectable, 'GetTrustLevel', retval=TrustLevel._enum_type_, vtbl=5)
+
+
+# activation
+@GUID('00000035-0000-0000-c000-000000000046')
+class IActivationFactory(IInspectable):
+    pass
+
+
+define_winrt_com_method(IActivationFactory, 'ActivateInstance', retval=IInspectable, vtbl=6)

autohelper/rotypes/roapi.py

@@ -0,0 +1,30 @@
+from functools import lru_cache
+
+from .inspectable import IInspectable, IActivationFactory
+from .types import *
+from .winstring import HSTRING
+
+combase = windll.LoadLibrary('combase.dll')
+RoGetActivationFactory = combase.RoGetActivationFactory
+RoGetActivationFactory.argtypes = (HSTRING, REFGUID, POINTER(IInspectable))
+RoGetActivationFactory.restype = check_hresult
+
+
+class RO_INIT_TYPE(INT):
+    RO_INIT_SINGLETHREADED = 0
+    RO_INIT_MULTITHREADED = 1
+
+
+RoInitialize = combase.RoInitialize
+RoInitialize.argtypes = (RO_INIT_TYPE,)
+RoInitialize.restype = check_hresult
+
+
+@lru_cache()
+def GetActivationFactory(classname, interface=IActivationFactory):
+    insp = interface()
+    RoGetActivationFactory(classname, interface.GUID, byref(insp))
+    return insp
+
+
+RoInitialize(RO_INIT_TYPE.RO_INIT_SINGLETHREADED)

autohelper/rotypes/types.py

@@ -0,0 +1,77 @@
+from ctypes import *
+from ctypes.wintypes import *
+
+HRESULT = LONG
+
+VOIDPP = POINTER(c_void_p)
+
+S_OK = 0
+S_FALSE = 1
+
+E_FAIL = -2147467259  # 0x80004005L
+E_NOTIMPL = -2147467263  # 0x80004001L
+E_NOINTERFACE = -2147467262  # 0x80004002L
+E_BOUNDS = -2147483637  # 0x8000000BL
+
+
+def check_hresult(hr):
+    # print('HRESULT = 0x%08X' % (hr & 0xFFFFFFFF))
+    if (hr & 0x80000000) != 0:
+        if hr == E_NOTIMPL:
+            raise NotImplementedError
+        elif hr == E_NOINTERFACE:
+            raise TypeError("E_NOINTERFACE")
+        elif hr == E_BOUNDS:
+            raise IndexError  # for old style iterator protocol
+        e = OSError("[HRESULT 0x%08X] %s" % (hr & 0xFFFFFFFF, FormatError(hr)))
+        e.winerror = hr & 0xFFFFFFFF
+        raise e
+    return hr
+
+
+class GUID(Structure):
+    _fields_ = [("Data1", DWORD),
+                ("Data2", WORD),
+                ("Data3", WORD),
+                ("Data4", c_uint8 * 8)]
+
+    def __init__(self, *initwith):
+        if len(initwith) == 1 and isinstance(initwith[0], str):
+            strrepr = initwith[0]
+            if strrepr.startswith('{'):
+                strrepr = strrepr[1:-1]
+            part1, part2, part3, part4, part5 = strrepr.split('-', 5)
+            self.Data1 = int(part1, 16)
+            self.Data2 = int(part2, 16)
+            self.Data3 = int(part3, 16)
+            self.Data4 = (int(part4[0:2], 16), int(part4[2:4], 16),
+                          int(part5[0:2], 16), int(part5[2:4], 16), int(part5[4:6], 16), int(part5[6:8], 16),
+                          int(part5[8:10], 16), int(part5[10:12], 16))
+        elif len(initwith) == 4:
+            self.Data1, self.Data2, self.Data3, self.Data4 = initwith
+        elif len(initwith) == 11:
+            self.Data1, self.Data2, self.Data3, self.Data4 = (*initwith[0:3], initwith[3:])
+        else:
+            raise ArgumentError(len(initwith))
+
+    def __str__(self):
+        return '%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x' % (
+            self.Data1, self.Data2, self.Data3, *list(self.Data4))
+
+    def __repr__(self):
+        return 'GUID(%s)' % repr(str(self))
+
+    def __eq__(self, other):
+        return isinstance(other, GUID) and bytes(self) == bytes(other)
+
+    def __hash__(self):
+        # We make GUID instances hashable, although they are mutable.
+        return hash(bytes(self))
+
+    def __call__(self, victim):
+        """for use as class decorator"""
+        victim.GUID = self
+        return victim
+
+
+REFGUID = POINTER(GUID)

autohelper/rotypes/winstring.py

@@ -0,0 +1,44 @@
+import ctypes
+import weakref
+
+from .types import check_hresult
+
+combase = ctypes.windll.LoadLibrary("combase.dll")
+WindowsCreateString = combase.WindowsCreateString
+WindowsCreateString.argtypes = (ctypes.c_void_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_void_p))
+WindowsCreateString.restype = check_hresult
+
+WindowsDeleteString = combase.WindowsDeleteString
+WindowsDeleteString.argtypes = (ctypes.c_void_p,)
+WindowsDeleteString.restype = check_hresult
+
+WindowsGetStringRawBuffer = combase.WindowsGetStringRawBuffer
+WindowsGetStringRawBuffer.argtypes = (ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint32))
+WindowsGetStringRawBuffer.restype = ctypes.c_void_p
+
+
+class HSTRING(ctypes.c_void_p):
+    def __init__(self, s=None):
+        super().__init__()
+        if s is None or len(s) == 0:
+            self.value = None
+            return
+        u16str = s.encode("utf-16-le") + b"\x00\x00"
+        u16len = (len(u16str) // 2) - 1
+        WindowsCreateString(u16str, ctypes.c_uint32(u16len), ctypes.byref(self))
+        self._finalizer = weakref.finalize(self, WindowsDeleteString, self.value)
+        # only register finalizer if we created the string
+
+    def __str__(self):
+        if self.value is None:
+            return ""
+        length = ctypes.c_uint32()
+        ptr = WindowsGetStringRawBuffer(self, ctypes.byref(length))
+        return ctypes.wstring_at(ptr, length.value)
+
+    def __repr__(self):
+        return "HSTRING(%s)" % repr(str(self))
+
+    @classmethod
+    def from_param(cls, s):
+        return cls(s)

autohelper/save/BlackBarProcessor.py

@@ -0,0 +1,25 @@
+import cv2
+import numpy as np
+
+from autohelper.save.PostProcessor import PostProcessor
+
+
+class BlackBarProcessor(PostProcessor):
+    def __init__(self, x, y, width, height, color=(1, 1, 1)):
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+        self.color = color
+
+    def process(self, image: np.ndarray):
+        height, width = image.shape[:2]
+        # Calculate absolute coordinates
+        x = int(self.x * width)
+        y = int(self.y * height)
+        abs_width = int(self.width * width)
+        abs_height = int(self.height * height)
+
+        # Draw a black rectangle
+        cv2.rectangle(image, (x, y), (x + abs_width, y + abs_height), self.color, -1)
+        print(f"cv2.rectangle ({x},{y},{abs_width},{abs_height})")

autohelper/save/PostProcessor.py

@@ -0,0 +1,6 @@
+import numpy as np
+
+
+class PostProcessor:
+    def process(image: np.ndarray):
+        pass

autohelper/save/SaveByInterval.py

@@ -0,0 +1,30 @@
+import time
+
+import cv2
+
+from autohelper.capture.windows.WindowsGraphicsCaptureMethod import BaseCaptureMethod
+
+
+class SaveByInterval:
+
+    def __init__(self, method: "BaseCaptureMethod", interval=1):
+        self.interval = interval
+        self.method = method
+
+    def save(self):
+        for i in range(5):
+            print(f"Log message {i}")
+            frame, err = self.method.get_frame()
+            if frame is not None:
+                filename = f"images/{i}.jpg"
+                # Save the image
+                cv2.imwrite(filename, frame)
+            time.sleep(1)
+        self.method.close()
+        print("Thread completed its execution.")
+
+    def wait_until_done(self):
+        # thread = threading.Thread(target=self.save)
+        # thread.start()
+        # thread.join()
+        pass

autohelper/save/SaveByKeyPress.py

@@ -0,0 +1,27 @@
+from pynput import keyboard
+
+from autohelper.capture.windows.WindowsGraphicsCaptureMethod import BaseCaptureMethod
+from autohelper.save.PostProcessor import PostProcessor
+from autohelper.save.SaveMethodBase import SaveMethodBase
+
+
+class SaveByKeyPress(SaveMethodBase):
+
+    def __init__(self, method: BaseCaptureMethod, image_processor: PostProcessor = None, capture_key="c", stop_key="x"):
+        super().__init__(method, image_processor)
+        self.capture_key = capture_key
+        self.stop_key = stop_key
+        listener = keyboard.Listener(on_release=self.on_key_release)
+        listener.start()
+
+    def on_key_release(self, key):
+        print(f'Key {key} released')
+        try:
+            if key.char == self.capture_key:
+                print(f'is capture_key call save()')
+                self.save()
+            elif key.char == self.stop_key:
+                self.stop()
+                return False
+        except AttributeError as e:
+            print(f'AttributeError {e} key {key} released')

autohelper/save/SaveMethodBase.py

@@ -0,0 +1,46 @@
+import os
+import threading
+
+import cv2
+
+from autohelper.capture.windows.WindowsGraphicsCaptureMethod import BaseCaptureMethod
+from autohelper.save.PostProcessor import PostProcessor
+
+
+class SaveMethodBase:
+
+    def __init__(self, method: BaseCaptureMethod, image_processor: PostProcessor = None):
+        self.method = method
+        self.image_processor = image_processor
+        self.i = 1
+        self.thread = threading.Thread(target=self.run)
+        self.dir = "images"
+        # Check if the directory exists, and create it if it doesn't
+        if not os.path.exists(self.dir):
+            os.makedirs(self.dir)
+        self.thread.start()
+        self.exit_event = threading.Event()
+
+    def save(self):
+        frame = self.method.get_frame()
+        if frame is not None:
+            if self.image_processor is not None:
+                self.image_processor.process(frame)
+            filename = f"{self.dir}/{self.i}.jpg"
+            self.i += 1
+            # Save the image
+            cv2.imwrite(filename, frame)
+
+    def run(self):
+        print("Thread started")
+        while not self.exit_event.is_set():
+            # Do some work here
+            # print("Thread is running...")
+            self.exit_event.wait(1)  # Wait for 1 second or until the event is set
+        print("Thread exiting")
+
+    def stop(self):
+        self.exit_event.set()
+
+    def wait_until_done(self):
+        self.thread.join()

autohelper/scene/FeatureScene.py

@@ -0,0 +1,14 @@
+from abc import abstractmethod
+
+from autohelper.feature.FindFeature import FindFeature
+from autohelper.scene.Scene import Scene
+
+
+class FindFeatureScene(Scene, FindFeature):
+    def __init__(self):
+        Scene.__init__(self)
+        self.feature_set = None
+
+    @abstractmethod
+    def detect(self, frame):
+        return False

autohelper/scene/Scene.py

@@ -0,0 +1,21 @@
+from abc import abstractmethod
+
+from autohelper.gui.Communicate import communicate
+from autohelper.logging.Logger import get_logger
+from autohelper.task.ExecutorOperation import ExecutorOperation
+
+
+class Scene(ExecutorOperation):
+    name = None
+
+    def __init__(self):
+        self.name = self.__class__.__name__
+        self.logger = get_logger(self.__class__.__name__)
+
+    @abstractmethod
+    def detect(self, frame):
+        return False
+
+    @staticmethod
+    def draw_boxes(feature_name, boxes, color="red"):
+        communicate.draw_box.emit(feature_name, boxes, color)