win32more-core 0.7.0__tar.gz

win32more_core-0.7.0/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

win32more_core-0.7.0/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: win32more-core
+Version: 0.7.0

win32more_core-0.7.0/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "win32more-core"
+version = "0.7.0"
+dependencies = []
+
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/win32more"]

win32more_core-0.7.0/src/win32more/__init__.py

@@ -0,0 +1,36 @@
+# ruff: noqa: F401
+from . import _win32api
+from ._boxing import box_value, unbox_value
+from ._comclass import ComClass
+from ._comerror import ComError
+from ._win32 import (
+    FAILED,
+    SUCCEEDED,
+    WINFUNCTYPE,
+    Boolean,
+    Byte,
+    Bytes,
+    Char,
+    Double,
+    Guid,
+    Int16,
+    Int32,
+    Int64,
+    IntPtr,
+    SByte,
+    Single,
+    String,
+    UInt16,
+    UInt32,
+    UInt64,
+    UIntPtr,
+    Void,
+    VoidPtr,
+    WinError,
+    windll,
+)
+
+# Initialize COM Multithreaded Apartment.
+# Call CoInitializeEx(None, COINIT_APARTMENTTHREADED) explicitly for Single-Threaded Apartment.
+if FAILED(_win32api.CoIncrementMTAUsage(VoidPtr())):
+    raise WinError()

win32more_core-0.7.0/src/win32more/_boxing.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from ._win32api import IInspectable
+
+
+# FIXME: Add more conversion.
+def box_value(value: object) -> IInspectable:
+    from win32more.Windows.Foundation import PropertyValue
+
+    if isinstance(value, str):
+        return PropertyValue.CreateString(value)
+    elif isinstance(value, bool):
+        return PropertyValue.CreateBoolean(value)
+    raise NotImplementedError(f"box_value: {type(value)}")
+
+
+def unbox_value(value: IInspectable):
+    from win32more.Windows.Foundation import IPropertyValue, PropertyType
+
+    property_value = value.as_(IPropertyValue)
+
+    if property_value.Type == PropertyType.Empty:
+        return None
+    elif property_value.Type == PropertyType.UInt8:
+        return property_value.GetUInt8()
+    elif property_value.Type == PropertyType.Int16:
+        return property_value.GetInt16()
+    elif property_value.Type == PropertyType.UInt16:
+        return property_value.GetUInt16()
+    elif property_value.Type == PropertyType.Int32:
+        return property_value.GetInt32()
+    elif property_value.Type == PropertyType.UInt32:
+        return property_value.GetUInt32()
+    elif property_value.Type == PropertyType.Int64:
+        return property_value.GetInt64()
+    elif property_value.Type == PropertyType.UInt64:
+        return property_value.GetUInt64()
+    elif property_value.Type == PropertyType.Single:
+        return property_value.GetSingle()
+    elif property_value.Type == PropertyType.Double:
+        return property_value.GetDouble()
+    elif property_value.Type == PropertyType.Char16:
+        return property_value.GetChar16()
+    elif property_value.Type == PropertyType.Boolean:
+        return property_value.GetBoolean()
+    elif property_value.Type == PropertyType.String:
+        return property_value.GetString()
+    elif property_value.Type == PropertyType.Inspectable:
+        return value
+    elif property_value.Type == PropertyType.DateTime:
+        return property_value.GetDateTime()
+    elif property_value.Type == PropertyType.TimeSpan:
+        return property_value.GetTimeSpan()
+    elif property_value.Type == PropertyType.Guid:
+        return property_value.GetGuid()
+    elif property_value.Type == PropertyType.Point:
+        return property_value.GetPoint()
+    elif property_value.Type == PropertyType.Size:
+        return property_value.GetSize()
+    elif property_value.Type == PropertyType.Rect:
+        return property_value.GetRect()
+    elif property_value.Type == PropertyType.UInt8Array:
+        r = []
+        property_value.GetUInt8Array(r)
+        return r
+    elif property_value.Type == PropertyType.Int16Array:
+        r = []
+        property_value.GetInt16Array(r)
+        return r
+    elif property_value.Type == PropertyType.UInt16Array:
+        r = []
+        property_value.GetUInt16Array(r)
+        return r
+    elif property_value.Type == PropertyType.Int32Array:
+        r = []
+        property_value.GetInt32Array(r)
+        return r
+    elif property_value.Type == PropertyType.UInt32Array:
+        r = []
+        property_value.GetUInt32Array(r)
+        return r
+    elif property_value.Type == PropertyType.Int64Array:
+        r = []
+        property_value.GetInt64Array(r)
+        return r
+    elif property_value.Type == PropertyType.UInt64Array:
+        r = []
+        property_value.GetUInt64Array(r)
+        return r
+    elif property_value.Type == PropertyType.SingleArray:
+        r = []
+        property_value.GetSingleArray(r)
+        return r
+    elif property_value.Type == PropertyType.DoubleArray:
+        r = []
+        property_value.GetDoubleArray(r)
+        return r
+    elif property_value.Type == PropertyType.Char16Array:
+        r = []
+        property_value.GetChar16Array(r)
+        return r
+    elif property_value.Type == PropertyType.BooleanArray:
+        r = []
+        property_value.GetBooleanArray(r)
+        return r
+    elif property_value.Type == PropertyType.StringArray:
+        r = []
+        property_value.GetStringArray(r)
+        return r
+    elif property_value.Type == PropertyType.InspectableArray:
+        r = []
+        property_value.GetInspectableArray(r)
+        return r
+    elif property_value.Type == PropertyType.DateTimeArray:
+        r = []
+        property_value.GetDateTimeArray(r)
+        return r
+    elif property_value.Type == PropertyType.TimeSpanArray:
+        r = []
+        property_value.GetTimeSpanArray(r)
+        return r
+    elif property_value.Type == PropertyType.GuidArray:
+        r = []
+        property_value.GetGuidArray(r)
+        return r
+    elif property_value.Type == PropertyType.PointArray:
+        r = []
+        property_value.GetPointArray(r)
+        return r
+    elif property_value.Type == PropertyType.SizeArray:
+        r = []
+        property_value.GetSizeArray(r)
+        return r
+    elif property_value.Type == PropertyType.RectArray:
+        r = []
+        property_value.GetRectArray(r)
+        return r
+    # elif property_value.Type == PropertyType.OtherType:
+    # elif property_value.Type == PropertyType.OtherTypeArray:
+    else:
+        raise NotImplementedError(f"unbox_value: {property_value.Type}")

win32more_core-0.7.0/src/win32more/_bstr.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from ctypes import wstring_at
+
+from ._win32 import UIntPtr
+from ._win32api import BSTR, SysAllocStringLen, SysFreeString, SysStringLen
+
+
+class bstr(BSTR):
+    def __init__(self, obj=None, own=False):
+        super().__init__()
+        if obj is None:
+            self.value = 0
+        elif isinstance(obj, str):
+            self.value = SysAllocStringLen(obj, len(obj), _as_intptr=True)
+        else:
+            raise ValueError(obj)
+        self._own = own
+
+    def __del__(self):
+        if getattr(self, "_own", False):
+            self.clear()
+
+    def clear(self):
+        if self.value:
+            SysFreeString(self)
+            self.value = 0
+
+    def __len__(self):
+        return SysStringLen(self)
+
+    def __str__(self):
+        return wstring_at(self, len(self))
+
+    def __int__(self):
+        return UIntPtr.from_buffer(self).value

win32more_core-0.7.0/src/win32more/_comclass.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+import logging
+import sys
+from collections.abc import Iterable
+from contextlib import ExitStack
+from ctypes import POINTER, Structure, addressof, c_void_p, cast, py_object, sizeof
+from functools import partial
+from typing import Any, _GenericAlias, get_args, get_origin
+
+from ._comerror import set_error_info
+from ._generic import (
+    generic_get_type_hints,
+    get_origin_or_itself,
+    get_original_class,
+    get_specialized_bases,
+    is_generic_alias,
+)
+from ._hstr import hstr
+from ._ro import ro_get_parameterized_type_instance_iid
+from ._win32 import WINFUNCTYPE, ComMethod, ComPtr, Guid, UInt32, Void, VoidPtr, commethod
+from ._win32api import (
+    E_FAIL,
+    E_NOINTERFACE,
+    HRESULT,
+    HSTRING,
+    S_OK,
+    BaseTrust,
+    CoTaskMemAlloc,
+    IAgileObject,
+    IInspectable,
+    IUnknown,
+    RoOriginateError,
+    TrustLevel,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class _lazy_winrt:
+    def __getattr__(self, name):
+        global _winrt
+        from . import _winrt
+
+        return getattr(_winrt, name)
+
+
+_winrt = _lazy_winrt()
+
+
+def is_com_class(cls):
+    return issubclass(get_origin_or_itself(cls), ComPtr)
+
+
+def is_com_instance(obj):
+    return isinstance(obj, ComPtr)
+
+
+class ComClass(ComPtr):
+    _keep_reference_in_python_world_ = {}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._iid_vtbls = self._make_iid_vtbls()
+        self.value = addressof(self._iid_vtbls[0][1])  # select default interface
+        self._refcount = 0
+        self.AddRef()
+        self._inner = self._compose()
+
+    def _make_iid_vtbls(self) -> list[tuple[Guid, Vtbl]]:
+        iid_vtbls = []
+        for interface in self._implemented_interfaces():
+            iid = self._get_iid(interface)
+            vtbl = Vtbl(self, interface)
+            iid_vtbls.append((iid, vtbl))
+        return iid_vtbls
+
+    def _get_iid(self, interface):
+        if is_generic_alias(interface):
+            return ro_get_parameterized_type_instance_iid(interface)
+        elif "_iid_" in interface.__dict__:
+            return interface.__dict__["_iid_"]
+        else:
+            raise ValueError("Cannot get iid")
+
+    def _implemented_interfaces(self) -> list[_GenericAlias | type]:
+        r = []
+        for base in self._enumerate_specialized_bases_recursively(get_original_class(self)):
+            if is_generic_alias(base) and "_piid_" in get_origin(base).__dict__:
+                r.append(base)
+            elif "_iid_" in base.__dict__:
+                r.append(base)
+        r.append(IAgileObject)
+        r.append(ISelf)
+        return r
+
+    def _enumerate_specialized_bases_recursively(self, cls: _GenericAlias | type) -> Iterable[_GenericAlias | type]:
+        for base in get_specialized_bases(cls):
+            yield base
+            yield from self._enumerate_specialized_bases_recursively(base)
+
+    @classmethod
+    def _runtime_class_name(cls) -> str:
+        return f"{cls.__module__}.{cls.__qualname__}"
+
+    def _compose(self) -> IInspectable:
+        for base in type(self).__mro__:
+            # FIXME: ComposableAttribute should be checked.
+            if issubclass(base, IInspectable) and "CreateInstance" in base.__dict__:
+                inner = IInspectable()
+                base.CreateInstance(self, inner)
+                return inner
+        return None
+
+    def QueryInterface(self, riid: POINTER(Guid), ppvObject: POINTER(VoidPtr)) -> HRESULT:
+        for iid, vtbl in self._iid_vtbls:
+            if riid[0] == iid:
+                ppvObject[0] = addressof(vtbl)
+                self.AddRef()
+                return S_OK
+        if self._inner is not None:
+            return self._inner.QueryInterface(riid, ppvObject)
+        return E_NOINTERFACE
+
+    def AddRef(self) -> UInt32:
+        self._refcount += 1
+        if self._refcount == 1:
+            self._keep_reference_in_python_world_[id(self)] = self
+        return self._refcount
+
+    def Release(self) -> UInt32:
+        self._refcount -= 1
+        if self._refcount == 0:
+            del self._keep_reference_in_python_world_[id(self)]
+        return self._refcount
+
+    def GetIids(self, iidCount: POINTER(UInt32), iids: POINTER(POINTER(Guid))) -> HRESULT:
+        iidCount[0] = len(self._iid_vtbls)
+        iids[0] = CoTaskMemAlloc(sizeof(VoidPtr) * len(self._iid_vtbls))
+        if iids[0] is None:
+            return E_FAIL
+        for i, (iid, vtbl) in enumerate(self._iid_vtbls):
+            iids[0][i] = iid
+        return S_OK
+
+    def GetRuntimeClassName(self, className: POINTER(HSTRING)) -> HRESULT:
+        className[0] = hstr(self._runtime_class_name())
+        return S_OK
+
+    def GetTrustLevel(self, trustLevel: POINTER(TrustLevel)) -> HRESULT:
+        trustLevel[0] = BaseTrust
+        return S_OK
+
+    # ISelf.GetSelf()
+    def GetSelf(self) -> object:
+        return self
+
+
+class Vtbl(Structure):
+    _fields_ = [("lpvtbl", POINTER(c_void_p))]
+
+    def __init__(self, owner, interface):
+        self._owner = owner
+        self._interface = interface
+        self._keep_reference_in_python_world_ = []
+        self.lpvtbl = self._make_lpvtbl()
+
+    def _make_lpvtbl(self):
+        methods = self._interface_methods()
+        vtbl_size = max(method._vtbl_index for method in methods) + 1
+        lpvtbl = (c_void_p * vtbl_size)()
+        for method in methods:
+            if isinstance(method, _winrt.WinrtMethod):
+                lpvtbl[method._vtbl_index] = self._make_thunk_winrt(method)
+            else:
+                lpvtbl[method._vtbl_index] = self._make_thunk_com(method)
+        return lpvtbl
+
+    def _interface_methods(self):
+        if sys.version_info < (3, 10) and is_generic_alias(self._interface):
+            interface = get_origin(self._interface)
+        else:
+            interface = self._interface
+        methods = []
+        for name in dir(interface):
+            if isinstance(getattr(interface, name), (ComMethod, _winrt.WinrtMethod)):
+                methods.append(getattr(interface, name))
+        return methods
+
+    def _make_thunk_com(self, method):
+        hints = generic_get_type_hints(method._prototype, self._interface)
+        restype = hints.pop("return")
+        argtypes = [self._make_allocator(t) for t in hints.values()]
+        closure = partial(self._com_callback_error_check, getattr(self._owner, method._prototype.__name__))
+        thunk = WINFUNCTYPE(restype, c_void_p, *argtypes)(closure)
+        self._keep_reference_in_python_world_.append(thunk)
+        return cast(thunk, c_void_p)
+
+    def _make_thunk_winrt(self, method):
+        hints = generic_get_type_hints(method._prototype, self._interface)
+        restype = hints.pop("return")
+        argtypes = []
+        for type_ in hints.values():
+            if _winrt.is_passarray_class(type_):
+                argtypes.append(UInt32)
+                argtypes.append(POINTER(get_args(type_)[0]))
+            elif _winrt.is_fillarray_class(type_):
+                argtypes.append(UInt32)
+                argtypes.append(POINTER(get_args(type_)[0]))
+            elif _winrt.is_receivearray_class(type_):
+                argtypes.append(POINTER(UInt32))
+                argtypes.append(POINTER(POINTER(get_args(type_)[0])))
+            else:
+                argtypes.append(self._make_allocator(type_))
+        if restype is Void:
+            pass
+        elif _winrt.is_receivearray_class(restype):
+            argtypes.append(POINTER(UInt32))
+            argtypes.append(POINTER(POINTER(get_args(restype)[0])))
+        elif is_generic_alias(restype):
+            argtypes.append(POINTER(get_origin(restype)))
+        else:
+            argtypes.append(POINTER(restype))
+        closure = partial(
+            self._winrt_callback_error_check, getattr(self._owner, method._prototype.__name__), restype, hints
+        )
+        thunk = WINFUNCTYPE(HRESULT, c_void_p, *argtypes)(closure)
+        self._keep_reference_in_python_world_.append(thunk)
+        return cast(thunk, c_void_p)
+
+    # allocate winrt runtime class without constructor.
+    def _make_allocator(self, t):
+        if is_generic_alias(t) or issubclass(t, ComPtr):
+            return type(c_void_p)("Allocator", (c_void_p,), {"__new__": lambda _: t(own=False)})
+        return t
+
+    def _com_callback_error_check(self, callback, this, *args):
+        try:
+            return callback(*args)
+        except Exception as exc:
+            logger.exception(f"Unhandled exception caught: {callback}{args}")
+            set_error_info(f"{exc.__class__.__name__}: {exc}")
+            return E_FAIL
+
+    def _winrt_callback_error_check(self, callback, restype, hints, this, *args):
+        try:
+            self._winrt_callback(callback, restype, hints, this, args)
+            return S_OK
+        except Exception as exc:
+            logger.exception(f"Unhandled exception caught: {callback}{args}")
+            RoOriginateError(E_FAIL, hstr(f"{exc.__class__.__name__}: {exc}", own=True))
+            return E_FAIL
+
+    def _winrt_callback(self, callback, restype, hints, this, args):
+        args = list(args)
+        with ExitStack() as exitstack:
+            pyargs = []
+            for type_ in hints.values():
+                self._add_argument(type_, args, pyargs, exitstack)
+            result = callback(*pyargs)
+        self._handle_result(restype, args, result)
+
+    def _add_argument(self, type_: type, args: list[Any], pyargs: list[Any], exitstack) -> None:
+        if _winrt.is_passarray_class(type_):
+            exitstack.enter_context(_winrt.PassArrayCallback(get_args(type_)[0], args.pop(0), args.pop(0), pyargs))
+        elif _winrt.is_fillarray_class(type_):
+            exitstack.enter_context(_winrt.FillArrayCallback(get_args(type_)[0], args.pop(0), args.pop(0), pyargs))
+        elif _winrt.is_receivearray_class(type_):
+            exitstack.enter_context(_winrt.ReceiveArrayCallback(get_args(type_)[0], args.pop(0), args.pop(0), pyargs))
+        elif type_ is hstr:
+            pyargs.append(str(args.pop(0)))
+        else:
+            pyargs.append(args.pop(0))
+
+    def _handle_result(self, restype: type, args: list[Any], result: Any) -> Any:
+        if restype is Void:
+            pass
+        elif _winrt.is_receivearray_class(restype):
+            return_length, return_pointer = args
+            _winrt.ReceiveArrayCallback.handle_result(get_args(restype)[0], return_length, return_pointer, result)
+        elif restype is hstr:
+            return_pointer = args[0]
+            return_pointer[0] = hstr(result)
+        elif is_com_class(restype):
+            return_pointer = args[0]
+            if result:
+                result.AddRef()
+            return_pointer[0] = result
+        else:
+            return_pointer = args[0]
+            return_pointer[0] = result
+
+
+class ISelf(IUnknown):
+    _iid_ = Guid("{18320492-860a-4c7b-ad7c-6cd65c88c09e}")
+
+    @commethod(3)
+    def GetSelf(self) -> py_object: ...