ok-script 0.0.7__py3-none-any.whl

autohelper/logging/Logger.py

@@ -0,0 +1,103 @@
+import logging
+import os
+import traceback
+from logging.handlers import TimedRotatingFileHandler
+
+from autohelper.gui.Communicate import communicate
+from autohelper.util.path import get_path_relative_to_exe, ensure_dir_for_file
+
+
+class CommunicateHandler(logging.Handler):
+    def __init__(self):
+        super().__init__()
+
+    def emit(self, record):
+        log_message = self.format(record)
+        communicate.log.emit(record.levelno, log_message)
+
+
+formatter = logging.Formatter('%(asctime)s %(levelname)s %(threadName)s %(message)s')
+communicate_handler = CommunicateHandler()
+communicate_handler.setFormatter(formatter)
+
+
+def get_substring_from_last_dot_exclusive(s):
+    # Find the last occurrence of "."
+    last_dot_index = s.rfind(".")
+    # If there's no ".", return an empty string or the original string based on your need
+    if last_dot_index == -1:
+        return ""  # or return s to return the whole string if there's no dot
+    # Slice the string from just after the last "." to the end
+    return s[last_dot_index + 1:]
+
+
+auto_helper_logger = logging.getLogger("autohelper")
+
+
+def config_logger(config):
+    if config.get('debug'):
+        auto_helper_logger.setLevel(logging.DEBUG)
+    else:
+        auto_helper_logger.setLevel(logging.INFO)
+
+    auto_helper_logger.handlers = []
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    auto_helper_logger.addHandler(console_handler)
+    auto_helper_logger.addHandler(communicate_handler)
+    logging.getLogger().handlers = []
+
+    if config.get('log_file'):
+        logger_file = get_path_relative_to_exe(config.get('log_file'))
+        ensure_dir_for_file(logger_file)
+
+        os.makedirs("logs", exist_ok=True)
+        # File handler with rotation
+        file_handler = TimedRotatingFileHandler(logger_file, when="midnight", interval=1,
+                                                backupCount=7, encoding='utf-8')
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.DEBUG)  # File handler level
+        auto_helper_logger.addHandler(file_handler)
+
+    if config.get('error_log_file'):
+        error_log_file = get_path_relative_to_exe(config.get('error_log_file'))
+        ensure_dir_for_file(error_log_file)
+
+        os.makedirs("logs", exist_ok=True)
+        # File handler with rotation
+        file_handler = TimedRotatingFileHandler(error_log_file, when="midnight", interval=1,
+                                                backupCount=7, encoding='utf-8')
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.ERROR)  # File handler level
+        auto_helper_logger.addHandler(file_handler)
+
+
+class Logger:
+    def __init__(self, name):
+        # Initialize the logger with the name of the subclass
+        self.logger = auto_helper_logger
+        self.name = name.split('.')[-1]
+
+    def debug(self, message):
+        self.logger.debug(f"{self.name}:{message}")
+
+    def info(self, message):
+        self.logger.info(f"{self.name}:{message}")
+
+    def warning(self, message):
+        self.logger.warning(f"{self.name}:{message}")
+
+    def error(self, message, exception=None):
+        if exception is not None:
+            traceback.print_exc()
+            stack_trace_str = traceback.format_exc()
+        else:
+            stack_trace_str = ""
+        self.logger.error(f"{self.name}:{message} {stack_trace_str}")
+
+    def critical(self, message):
+        self.logger.critical(f"{self.name}:{message}")
+
+
+def get_logger(name):
+    return Logger(name)

autohelper/ocr/OCR.py

@@ -0,0 +1,50 @@
+import time
+
+from autohelper.feature.Box import Box, sort_boxes, find_boxes_by_name
+from autohelper.gui.Communicate import communicate
+from autohelper.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class OCR:
+    executor = None
+    default_threshold = 0.6
+
+    def ocr(self, box: Box = None, match=None, threshold=0):
+        if threshold == 0:
+            threshold = self.default_threshold
+        start = time.time()
+        image = self.frame
+        if image is not None:
+            if box is not None:
+                x, y, w, h = box.x, box.y, box.width, box.height
+                image = image[y:y + h, x:x + w]
+
+            result, _ = self.executor.ocr(image, use_det=True, use_cls=False, use_rec=True)
+            detected_boxes = []
+            # Process the results and create Box objects
+            if result is not None:
+                for res in result:
+                    pos = res[0]
+                    text = res[1]
+                    confidence = res[2]
+                    if confidence >= threshold:
+                        detected_box = Box(int(pos[0][0]), int(pos[0][1]), int(pos[2][0] - pos[0][0]),
+                                           int(pos[2][1] - pos[0][1]),
+                                           confidence, text)
+                        if box is not None:
+                            detected_box.x += box.x
+                            detected_box.y += box.y
+                        detected_boxes.append(detected_box)
+                if match is not None:
+                    detected_boxes = find_boxes_by_name(detected_boxes, match)
+            communicate.draw_box.emit("ocr", detected_boxes, "red")
+            communicate.draw_box.emit("ocr_zone", box, "blue")
+            logger.debug(f"ocr_zone {box} found result: {len(detected_boxes)}) time: {time.time() - start}")
+            return sort_boxes(detected_boxes)
+
+    def find_text(self, text, box: Box = None, confidence=0):
+        for result in self.ocr(box, confidence):
+            if result.name == text:
+                return result

autohelper/predict/predict.py

@@ -0,0 +1,45 @@
+import torch
+from PIL import Image, ImageDraw
+import numpy as np
+from ultralytics import YOLO
+
+# Load the model
+# model = torch.hub.load('ultralytics/yolov8', 'custom', path='models/best.pt')
+model = YOLO('models/best.pt')  # pretrained YOLOv8n model
+
+# Run batched inference on a list of images
+# results = model(['im1.jpg', 'im2.jpg'])  # return a list of Results objects
+
+# Load an image
+image_path = 'images/3.jpg'
+image = Image.open(image_path)
+
+# Perform inference
+results = model(image)
+
+# Extract data
+for result in results:
+    boxes = result.boxes  # Boxes object for bbox outputs
+    print(boxes)
+    masks = result.masks  # Masks object for segmentation masks outputs
+    keypoints = result.keypoints  # Keypoints object for pose outputs
+    probs = result.probs  # Probs object for classification outputs
+
+for r in results:
+    im_array = r.plot()  # plot a BGR numpy array of predictions
+    im = Image.fromarray(im_array[..., ::-1])  # RGB PIL image
+    im.show()  # show image
+    im.save('results.jpg')  # save image
+# labels, cord = results.xyxyn[0][:, -1], results.xyxyn[0][:, :-1]
+
+# # Draw bounding boxes and labels
+# draw = ImageDraw.Draw(image)
+# for label, (*xyxy,) in zip(labels, cord):
+#     label = model.module.names[int(label)]  # Get label name
+#     xyxy = (xyxy * np.array([image.width, image.height, image.width, image.height])).tolist()  # Scale coords
+#     draw.rectangle(xyxy, outline='red', width=3)
+#     draw.text(xyxy[:2], label, fill='red')
+
+# Save or display image
+# image.save('output/1.jpg')
+# image.show()

autohelper/rotypes/Windows/Foundation/Collections.py

@@ -0,0 +1,60 @@
+from ctypes import c_uint, c_uint32, c_bool
+from functools import lru_cache
+
+from _ctypes import POINTER
+
+from autohelper.rotypes.idldsl import define_winrt_com_method, pinterface_type
+from autohelper.rotypes.inspectable import IInspectable
+
+
+class IIterator_helpers:
+    def __next__(self):
+        if self.HasCurrent:
+            value = self.Current
+            self.MoveNext()
+            return value
+        raise StopIteration
+
+    def __iter__(self):
+        return self
+
+
+@lru_cache()
+def IIterator(T):
+    cls = pinterface_type('IIterator', '6a79e863-4300-459a-9966-cbb660963ee1', (T,), (IInspectable, IIterator_helpers))
+    define_winrt_com_method(cls, 'get_Current', propget=T, vtbl=6)
+    define_winrt_com_method(cls, 'get_HasCurrent', propget=c_bool, vtbl=7)
+    define_winrt_com_method(cls, 'MoveNext', retval=c_bool, vtbl=8)
+    define_winrt_com_method(cls, 'GetMany', c_uint, POINTER(T), POINTER(c_uint), retval=c_uint32, vtbl=9)
+    return cls
+
+
+class IIterable_helpers(object):
+    def __iter__(self):
+        return self.First
+
+
+@lru_cache()
+def IIterable(T):
+    cls = pinterface_type('IIterable', 'faa585ea-6214-4217-afda-7f46de5869b3', (T,), (IInspectable, IIterable_helpers))
+    define_winrt_com_method(cls, 'get_First', propget=IIterator(T), vtbl=6)
+    return cls
+
+
+class IVectorView_helpers:
+    def __len__(self):
+        return self.Size
+
+    def __getitem__(self, item):
+        return self.GetAt(c_uint(item))
+
+
+@lru_cache()
+def IVectorView(T):
+    cls = pinterface_type('IVectorView', 'bbe1fa4c-b0e3-4583-baef-1f1b2e483e56', (T,),
+                          (IIterable(T), IVectorView_helpers))
+    define_winrt_com_method(cls, 'GetAt', c_uint, retval=T, vtbl=6)
+    define_winrt_com_method(cls, 'get_Size', propget=c_uint32, vtbl=7)
+    define_winrt_com_method(cls, 'IndexOf', T, POINTER(c_uint32), retval=c_bool, vtbl=8)
+    define_winrt_com_method(cls, 'GetMany', c_uint, c_uint, POINTER(IInspectable), POINTER(c_uint), vtbl=9)
+    return cls

autohelper/rotypes/Windows/Foundation/__init__.py

@@ -0,0 +1,153 @@
+import asyncio
+from ctypes import Structure, c_float, HRESULT, c_int, windll, c_uint32, c_int32, WinError
+
+from autohelper.rotypes import delegate, HSTRING
+from autohelper.rotypes.idldsl import define_winrt_com_method, generics_cache, define_winrt_com_delegate, pinterface_type, \
+    GUID
+from autohelper.rotypes.inspectable import IInspectable, IUnknown
+
+_kernel32 = windll.LoadLibrary('kernel32.dll')
+_CreateEvent = _kernel32.CreateEventW
+_SetEvent = _kernel32.SetEvent
+_WaitForSingleObject = _kernel32.WaitForSingleObject
+_CloseHandle = _kernel32.CloseHandle
+
+
+class Rect(Structure):
+    _fields_ = (('x', c_float), ('y', c_float), ('width', c_float), ('height', c_float))
+
+
+class AsyncStatus(c_int32):
+    Started = 0
+    Completed = 1
+    Canceled = 2
+    Error = 3
+
+
+@GUID('00000036-0000-0000-C000-000000000046')
+class IAsyncInfo(IInspectable):
+    pass
+
+
+@generics_cache
+def AsyncOperationCompletedHandler(T):
+    cls = pinterface_type('IAsyncOperationCompletedHandler', 'fcdcf02c-e5d8-4478-915a-4d90b74b83a5', (T,),
+                          (IUnknown, delegate.delegatebase))
+    AsyncOperationCompletedHandler.known_types[(T,)] = cls
+    define_winrt_com_delegate(cls, IAsyncOperation(T), AsyncStatus)
+    return cls
+
+
+# IAsyncOperation<IInspectable>
+class IAsyncOperation_helpers:
+    def as_future(self):
+        # FIXME: doesn't work
+        future = asyncio.Future()
+        if self.Status == AsyncStatus.Completed:
+            future.set_result(self.GetResults())
+            return future
+
+        def callback(iao, status):
+            status = status.value
+            if status == AsyncStatus.Completed:
+                result = self.GetResults()
+                future.set_result(result)
+            elif status == AsyncStatus.Error:
+                hr = iao.ErrorCode
+                future.set_exception(WinError(hr))
+            elif status == AsyncStatus.Canceled:
+                future.cancel()
+
+        delegatetype = AsyncOperationCompletedHandler(self.__class__._typeparam[0])
+        delegateobj = delegatetype.delegate(callback)
+        self.Completed = delegateobj
+        return future
+
+    def wait(self):
+        if self.Status == AsyncStatus.Completed:
+            return self.GetResults()
+        event = _CreateEvent(None, False, False, None)
+        results = []
+
+        def callback(iao, status):
+            status = status.value
+            if status == AsyncStatus.Completed:
+                result = iao.GetResults()
+                results.append(result)
+                _SetEvent(event)
+            elif status == AsyncStatus.Error:
+                hr = iao.ErrorCode
+                results.append(WinError(hr))
+                _SetEvent(event)
+            elif status == AsyncStatus.Canceled:
+                results.append(RuntimeError('AsyncStatus.Canceled'))
+
+        delegatetype = AsyncOperationCompletedHandler(self.__class__._typeparam[0])
+        delegateobj = delegatetype.delegate(callback)
+        self.Completed = delegateobj
+        # delegateobj._detach()
+        _WaitForSingleObject(event, -1)
+        _CloseHandle(event)
+        result = results[0]
+        if isinstance(result, BaseException):
+            raise result
+        else:
+            return result
+
+    def __await__(self):
+        return self.as_future().__await__()
+
+
+@generics_cache
+def IAsyncOperation(T):
+    cls = pinterface_type('IAsyncOperation', '9fc2b0bb-e446-44e2-aa61-9cab8f636af2', (T,),
+                          (IAsyncInfo, IAsyncOperation_helpers))
+    IAsyncOperation.known_types[(T,)] = cls
+    define_winrt_com_method(cls, 'put_Completed', propput=AsyncOperationCompletedHandler(T), vtbl=6)
+    define_winrt_com_method(cls, 'get_Completed', propget=AsyncOperationCompletedHandler(T), vtbl=7)
+    define_winrt_com_method(cls, 'GetResults', retval=T, vtbl=8)
+    return cls
+
+
+@generics_cache
+def IReference(T):
+    cls = pinterface_type('IReference', '61c17706-2d65-11e0-9ae8-d48564015472', (T,), (IInspectable,))
+    IAsyncOperation.known_types[(T,)] = cls
+    define_winrt_com_method(cls, 'get_Value', propget=T, vtbl=6)
+    return cls
+
+
+@GUID('30d5a829-7fa4-4026-83bb-d75bae4ea99e')
+class IClosable(IInspectable):
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.Close()
+
+
+@GUID('96369f54-8eb6-48f0-abce-c1b211e627c3')
+class IStringable(IInspectable):
+    def __str__(self):
+        return str(self.ToString())
+
+
+@generics_cache
+def TypedEventHandler(TSender, TResult):
+    cls = pinterface_type('IAsyncOperationCompletedHandler',
+                          GUID(2648818996, 27361, 4576, 132, 225, 24, 169, 5, 188, 197, 63), (TSender, TResult),
+                          (IUnknown, delegate.delegatebase))
+    TypedEventHandler.known_types[(TSender, TResult)] = cls
+    define_winrt_com_delegate(cls, TSender, TResult)
+    return cls
+
+
+define_winrt_com_method(IAsyncInfo, 'get_Id', propget=c_uint32)
+define_winrt_com_method(IAsyncInfo, 'get_Status', propget=c_int)
+define_winrt_com_method(IAsyncInfo, 'get_ErrorCode', propget=HRESULT)
+define_winrt_com_method(IAsyncInfo, 'Cancel')
+define_winrt_com_method(IAsyncInfo, 'Close')
+
+define_winrt_com_method(IClosable, 'Close', vtbl=6)
+
+define_winrt_com_method(IStringable, 'ToString', retval=HSTRING, vtbl=6)

autohelper/rotypes/Windows/Globalization/__init__.py

@@ -0,0 +1,25 @@
+from autohelper.rotypes.idldsl import define_winrt_com_method, runtimeclass, _static_method, GUID
+from autohelper.rotypes.inspectable import IInspectable
+from autohelper.rotypes.winstring import HSTRING
+
+
+@GUID('EA79A752-F7C2-4265-B1BD-C4DEC4E4F080')
+class ILanguage(IInspectable):
+    pass
+
+
+@GUID('9B0252AC-0C27-44F8-B792-9793FB66C63E')
+class ILanguageFactory(IInspectable):
+    pass
+
+
+class Language(runtimeclass, ILanguage):
+    CreateLanguage = _static_method(ILanguageFactory, 'CreateLanguage')
+
+
+define_winrt_com_method(ILanguage, 'get_LanguageTag', propget=HSTRING, vtbl=6)
+define_winrt_com_method(ILanguage, 'get_DisplayName', propget=HSTRING, vtbl=7)
+define_winrt_com_method(ILanguage, 'get_NativeName', propget=HSTRING, vtbl=8)
+define_winrt_com_method(ILanguage, 'get_Script', propget=HSTRING, vtbl=9)
+
+define_winrt_com_method(ILanguageFactory, 'CreateLanguage', HSTRING, retval=Language, vtbl=6)

autohelper/rotypes/Windows/Graphics/Capture/__init__.py

@@ -0,0 +1,110 @@
+from ctypes import c_bool, c_int32, c_int64
+from ctypes.wintypes import HWND, HMONITOR
+
+from autohelper.rotypes.Windows.Foundation import IClosable, TypedEventHandler
+from autohelper.rotypes.Windows.Graphics import SizeInt32
+from autohelper.rotypes.Windows.Graphics.DirectX import DirectXPixelFormat
+from autohelper.rotypes.idldsl import define_winrt_com_method, runtimeclass, GUID, \
+    runtimeclass_add_statics
+from autohelper.rotypes.inspectable import IInspectable, IUnknown
+from autohelper.rotypes.types import REFGUID
+from autohelper.rotypes.winstring import HSTRING
+
+
+@GUID('FA50C623-38DA-4B32-ACF3-FA9734AD800E')
+class IDirect3D11CaptureFrame(IInspectable):
+    pass
+
+
+@GUID('24EB6D22-1975-422E-82E7-780DBD8DDF24')
+class IDirect3D11CaptureFramePool(IInspectable):
+    pass
+
+
+@GUID('589B103F-6BBC-5DF5-A991-02E28B3B66D5')
+class IDirect3D11CaptureFramePoolStatics2(IInspectable):
+    pass
+
+
+@GUID('79C3F95B-31F7-4EC2-A464-632EF5D30760')
+class IGraphicsCaptureItem(IInspectable):
+    pass
+
+
+@GUID('814E42A9-F70F-4AD7-939B-FDDCC6EB880D')
+class IGraphicsCaptureSession(IInspectable):
+    pass
+
+
+@GUID('2C39AE40-7D2E-5044-804E-8B6799D4CF9E')
+class IGraphicsCaptureSession2(IInspectable):
+    pass
+
+
+@GUID('F2CDD966-22AE-5EA1-9596-3A289344C3BE')
+class IGraphicsCaptureSession3(IInspectable):
+    pass
+
+
+@GUID('3628E81B-3CAC-4C60-B7F4-23CE0E0C3356')
+class IGraphicsCaptureItemInterop(IUnknown):
+    pass
+
+
+class Direct3D11CaptureFrame(runtimeclass, IDirect3D11CaptureFrame, IClosable):
+    pass
+
+
+class Direct3D11CaptureFramePool(runtimeclass, IDirect3D11CaptureFramePool, IClosable):
+    pass
+
+
+class GraphicsCaptureItem(runtimeclass, IGraphicsCaptureItem):
+    pass
+
+
+class GraphicsCaptureSession(runtimeclass, IGraphicsCaptureSession, IGraphicsCaptureSession2, IGraphicsCaptureSession3,
+                             IClosable):
+    pass
+
+
+define_winrt_com_method(IDirect3D11CaptureFrame, 'get_Surface', propget=IInspectable)
+define_winrt_com_method(IDirect3D11CaptureFrame, 'get_SystemRelativeTime',
+                        propget=c_int64)  # FIXME: Windows.Foundation.TimeSpan
+define_winrt_com_method(IDirect3D11CaptureFrame, 'get_ContentSize', propget=SizeInt32)
+
+define_winrt_com_method(IDirect3D11CaptureFramePool, 'Recreate',
+                        IInspectable['Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice'], DirectXPixelFormat,
+                        c_int32, SizeInt32)  # FIXME: Windows.Graphics.DirectX.DirectXPixelFormat
+define_winrt_com_method(IDirect3D11CaptureFramePool, 'TryGetNextFrame', retval=Direct3D11CaptureFrame)
+define_winrt_com_method(IDirect3D11CaptureFramePool, 'add_FrameArrived',
+                        TypedEventHandler(Direct3D11CaptureFramePool, IInspectable), retval=c_int64)
+define_winrt_com_method(IDirect3D11CaptureFramePool, 'remove_FrameArrived', c_int64)
+define_winrt_com_method(IDirect3D11CaptureFramePool, 'CreateCaptureSession', GraphicsCaptureItem,
+                        retval=GraphicsCaptureSession)
+define_winrt_com_method(IDirect3D11CaptureFramePool, 'get_DispatcherQueue',
+                        propget=IInspectable['Windows.System.DispatcherQueue'])
+
+define_winrt_com_method(IDirect3D11CaptureFramePoolStatics2, 'CreateFreeThreaded',
+                        IInspectable['Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice'], DirectXPixelFormat,
+                        c_int32, SizeInt32,
+                        retval=Direct3D11CaptureFramePool)  # R: Windows.Graphics.DirectX.DirectXPixelFormat
+
+define_winrt_com_method(IGraphicsCaptureItem, 'get_DisplayName', propget=HSTRING)
+define_winrt_com_method(IGraphicsCaptureItem, 'get_Size', propget=SizeInt32)
+define_winrt_com_method(IGraphicsCaptureItem, 'add_Closed', TypedEventHandler(GraphicsCaptureItem, IInspectable),
+                        retval=c_int64)
+define_winrt_com_method(IGraphicsCaptureItem, 'remove_Closed', c_int64)
+
+define_winrt_com_method(IGraphicsCaptureSession, 'StartCapture')
+
+define_winrt_com_method(IGraphicsCaptureSession2, 'get_IsCursorCaptureEnabled', propget=c_bool)
+define_winrt_com_method(IGraphicsCaptureSession2, 'put_IsCursorCaptureEnabled', propput=c_bool)
+
+define_winrt_com_method(IGraphicsCaptureSession3, 'get_IsBorderRequired', propget=c_bool)
+define_winrt_com_method(IGraphicsCaptureSession3, 'put_IsBorderRequired', propput=c_bool)
+
+define_winrt_com_method(IGraphicsCaptureItemInterop, 'CreateForWindow', HWND, REFGUID, retval=GraphicsCaptureItem)
+define_winrt_com_method(IGraphicsCaptureItemInterop, 'CreateForMonitor', HMONITOR, REFGUID, retval=GraphicsCaptureItem)
+
+runtimeclass_add_statics(Direct3D11CaptureFramePool, IDirect3D11CaptureFramePoolStatics2)

autohelper/rotypes/Windows/Graphics/DirectX/Direct3D11/__init__.py

@@ -0,0 +1,41 @@
+import ctypes
+
+import autohelper.rotypes as rotypes
+import autohelper.rotypes.Windows.Foundation
+import autohelper.rotypes.idldsl
+from autohelper.rotypes.types import REFGUID
+
+
+@rotypes.idldsl.GUID('A37624AB-8D5F-4650-9D3E-9EAE3D9BC670')
+class _IDirect3DDevice(rotypes.IInspectable):
+    pass
+
+
+class IDirect3DDevice(_IDirect3DDevice, rotypes.Windows.Foundation.IClosable):
+    pass
+
+
+@rotypes.idldsl.GUID('0BF4A146-13C1-4694-BEE3-7ABF15EAF586')
+class _IDirect3DSurface(rotypes.IInspectable):
+    pass
+
+
+class IDirect3DSurface(_IDirect3DSurface, rotypes.Windows.Foundation.IClosable):
+    pass
+
+
+@rotypes.idldsl.GUID('A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1')
+class IDirect3DDxgiInterfaceAccess(rotypes.IUnknown):
+    pass
+
+
+rotypes.idldsl.define_winrt_com_method(IDirect3DDxgiInterfaceAccess, 'GetInterface', REFGUID, retval=rotypes.IUnknown)
+
+_CreateDirect3D11DeviceFromDXGIDevice = ctypes.oledll.d3d11.CreateDirect3D11DeviceFromDXGIDevice
+_CreateDirect3D11DeviceFromDXGIDevice.argtypes = (rotypes.IUnknown, ctypes.POINTER(rotypes.IInspectable))
+
+
+def CreateDirect3D11DeviceFromDXGIDevice(dxgidev):
+    outptr = rotypes.IInspectable()
+    _CreateDirect3D11DeviceFromDXGIDevice(dxgidev, ctypes.byref(outptr))
+    return outptr