comtypes 1.4.9__zip → 1.4.11__zip

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/_post_coinit/unknwn.py

@@ -1,28 +1,29 @@
 # https://learn.microsoft.com/en-us/windows/win32/api/unknwn/
 
 import logging
-import sys
 from ctypes import HRESULT, POINTER, byref, c_ulong, c_void_p
-from typing import TYPE_CHECKING, ClassVar, List, Optional, Type, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, List, Optional, Type, TypeVar
 
-from comtypes import GUID, _ole32_nohresult, com_interface_registry
+import comtypes
+from comtypes import GUID, _CoUninitialize
 from comtypes._memberspec import STDMETHOD, ComMemberGenerator, DispMemberGenerator
 from comtypes._post_coinit import _cominterface_meta_patcher as _meta_patch
 from comtypes._post_coinit.instancemethod import instancemethod
 
 if TYPE_CHECKING:
+    from typing import Literal
+    from typing import Union as _UnionT
+
+    from comtypes import hints  # type: ignore
     from comtypes._memberspec import _ComMemberSpec, _DispMemberSpec
 
 logger = logging.getLogger(__name__)
 
 
 def _shutdown(
-    func=_ole32_nohresult.CoUninitialize,
+    func=_CoUninitialize,
     _debug=logger.debug,
-    _exc_clear=getattr(sys, "exc_clear", lambda: None),
-):
-    # Make sure no COM pointers stay in exception frames.
-    _exc_clear()
+) -> None:
     # Sometimes, CoUninitialize, running at Python shutdown,
     # raises an exception.  We suppress this when __debug__ is
     # False.
@@ -135,7 +136,7 @@ class _cominterface_meta(type):
 
         return self
 
-    def __setattr__(self, name, value):
+    def __setattr__(self, name: str, value: Any) -> None:
         if name == "_methods_":
             # XXX I'm no longer sure why the code generator generates
             # "_methods_ = []" in the interface definition, and later
@@ -149,11 +150,11 @@ class _cominterface_meta(type):
             self._make_specials()
         type.__setattr__(self, name, value)
 
-    def _make_specials(self):
+    def _make_specials(self) -> None:
         # This call installs methods that forward the Python protocols
         # to COM protocols.
 
-        def has_name(name):
+        def has_name(name: str) -> bool:
             # Determine whether a property or method named 'name'
             # exists
             if self._case_insensitive_:
@@ -168,7 +169,7 @@ class _cominterface_meta(type):
         if has_name("_NewEnum"):
             _meta_patch.iterator(self)
 
-    def _make_case_insensitive(self):
+    def _make_case_insensitive(self) -> None:
         # The __map_case__ dictionary maps lower case names to the
         # names in the original spelling to enable case insensitive
         # method and attribute access.
@@ -201,7 +202,7 @@ class _cominterface_meta(type):
             if self._case_insensitive_:
                 self.__map_case__[name.lower()] = name
 
-    def __get_baseinterface_methodcount(self):
+    def __get_baseinterface_methodcount(self) -> int:
         "Return the number of com methods in the base interfaces"
         result = 0
         for itf in self.mro()[1:-1]:
@@ -220,7 +221,7 @@ class _cominterface_meta(type):
         except KeyError:
             raise AttributeError("this class must define an _iid_")
         else:
-            com_interface_registry[str(iid)] = self
+            comtypes.com_interface_registry[str(iid)] = self  # type: ignore
         # create members
         vtbl_offset = self.__get_baseinterface_methodcount()
         member_gen = ComMemberGenerator(self.__name__, vtbl_offset, self._iid_)
@@ -265,7 +266,10 @@ class _compointer_meta(type(c_void_p), _cominterface_meta):
 class _compointer_base(c_void_p, metaclass=_compointer_meta):
     "base class for COM interface pointer classes"
 
-    def __del__(self, _debug=logger.debug):
+    if TYPE_CHECKING:
+        __com_interface__: ClassVar[Type["IUnknown"]]
+
+    def __del__(self, _debug=logger.debug) -> None:
         "Release the COM refcount we own."
         if self:
             # comtypes calls CoUninitialize() when the atexit handlers
@@ -279,7 +283,7 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
                 _debug("Release %s", self)
                 self.Release()  # type: ignore
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         if not isinstance(other, _compointer_base):
             return False
         # get the value property of the c_void_p baseclass, this is the pointer value
@@ -287,18 +291,18 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
             super(_compointer_base, self).value == super(_compointer_base, other).value
         )
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         """Return the hash value of the pointer."""
         # hash the pointer values
         return hash(super(_compointer_base, self).value)
 
     # redefine the .value property; return the object itself.
-    def __get_value(self):
+    def __get_value(self) -> "hints.Self":
         return self
 
     value = property(__get_value, doc="""Return self.""")
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         ptr = super(_compointer_base, self).value
         return f"<{self.__class__.__name__} ptr=0x{ptr or 0:x} at {id(self):x}>"
 
@@ -306,13 +310,14 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
     # wrapping the same COM interface.  This could happen because some interfaces
     # are contained in multiple typelibs.
     #
-    # It also allows to pass a CoClass instance to an api
-    # expecting a COM interface.
+    # It also allows to pass a COMObject instance to an api expecting a COM interface.
     @classmethod
-    def from_param(cls, value):
+    def from_param(
+        cls, value: "_UnionT[None, Literal[0], hints.Self, IUnknown, hints.COMObject]"
+    ) -> Any:
         """Convert 'value' into a COM pointer to the interface.
 
-        This method accepts a COM pointer, or a CoClass instance
+        This method accepts a COM pointer, or a COMObject/CoClass instance
         which is QueryInterface()d."""
         if value is None:
             return None
@@ -326,9 +331,9 @@ class _compointer_base(c_void_p, metaclass=_compointer_meta):
         # Do we need more checks here?
         if cls._iid_ == getattr(value, "_iid_", None):
             return value
-        # Accept an CoClass instance which exposes the interface required.
+        # Accept an COMObject instance which exposes the interface required.
         try:
-            table = value._com_pointers_
+            table = value._com_pointers_  # type: ignore
         except AttributeError:
             pass
         else:

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/_safearray.py

@@ -1,9 +1,9 @@
 """SAFEARRAY api functions, data types, and constants."""
 
-from ctypes import c_uint, c_ushort, c_void_p, POINTER, Structure, WinDLL
+from ctypes import POINTER, Structure, WinDLL, c_uint, c_ushort, c_void_p
 from ctypes.wintypes import DWORD, LONG, UINT, USHORT
 
-from comtypes import HRESULT, GUID
+from comtypes import GUID, HRESULT
 
 ################################################################
 # if __debug__:

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/_vtbl.py

@@ -17,29 +17,26 @@ from typing import Union as _UnionT
 
 import comtypes
 from comtypes import GUID, IUnknown, hresult
-from comtypes._memberspec import _encode_idl
+from comtypes._memberspec import (
+    DISPATCH_METHOD,
+    DISPATCH_PROPERTYGET,
+    DISPATCH_PROPERTYPUT,
+    DISPATCH_PROPERTYPUTREF,
+    _encode_idl,
+)
 from comtypes.errorinfo import ReportError, ReportException
 
 if TYPE_CHECKING:
     from ctypes import _FuncPointer
 
     from comtypes import hints  # type: ignore
-    from comtypes._memberspec import _ArgSpecElmType, _DispMemberSpec, _ParamFlagType
+    from comtypes._memberspec import _ComIdlFlags, _DispIdlFlags, _DispMemberSpec
 
 logger = logging.getLogger(__name__)
 _debug = logger.debug
 _warning = logger.warning
 _error = logger.error
 
-################################################################
-# COM object implementation
-
-# so we don't have to import comtypes.automation
-DISPATCH_METHOD = 1
-DISPATCH_PROPERTYGET = 2
-DISPATCH_PROPERTYPUT = 4
-DISPATCH_PROPERTYPUTREF = 8
-
 
 class E_NotImplemented(Exception):
     """COM method is not implemented"""
@@ -84,7 +81,7 @@ def _do_implement(interface_name: str, method_name: str) -> Callable[..., int]:
 def catch_errors(
     obj: "hints.COMObject",
     mth: Callable[..., Any],
-    paramflags: Optional[Tuple["_ParamFlagType", ...]],
+    paramflags: Optional[Tuple["hints.ParamFlagType", ...]],
     interface: Type[IUnknown],
     mthname: str,
 ) -> Callable[..., Any]:
@@ -133,7 +130,7 @@ def catch_errors(
 def hack(
     inst: "hints.COMObject",
     mth: Callable[..., Any],
-    paramflags: Optional[Tuple["_ParamFlagType", ...]],
+    paramflags: Optional[Tuple["hints.ParamFlagType", ...]],
     interface: Type[IUnknown],
     mthname: str,
 ) -> Callable[..., Any]:
@@ -241,8 +238,8 @@ class _MethodFinder(object):
         self,
         interface: Type[IUnknown],
         mthname: str,
-        paramflags: Optional[Tuple["_ParamFlagType", ...]],
-        idlflags: Tuple[_UnionT[str, int], ...],
+        paramflags: Optional[Tuple["hints.ParamFlagType", ...]],
+        idlflags: _UnionT["_ComIdlFlags", "_DispIdlFlags"],
     ) -> Callable[..., Any]:
         mth = self.find_impl(interface, mthname, paramflags, idlflags)
         if mth is None:
@@ -263,8 +260,8 @@ class _MethodFinder(object):
         self,
         interface: Type[IUnknown],
         mthname: str,
-        paramflags: Optional[Tuple["_ParamFlagType", ...]],
-        idlflags: Tuple[_UnionT[str, int], ...],
+        paramflags: Optional[Tuple["hints.ParamFlagType", ...]],
+        idlflags: _UnionT["_ComIdlFlags", "_DispIdlFlags"],
     ) -> Optional[Callable[..., Any]]:
         fq_name = f"{interface.__name__}_{mthname}"
         if interface._case_insensitive_:
@@ -340,25 +337,29 @@ def create_vtbl_mapping(
     methods: List[Callable[..., Any]] = []  # method implementations
     fields: List[Tuple[str, Type["_FuncPointer"]]] = []  # virtual function table
     iids: List[GUID] = []  # interface identifiers.
-    # iterate over interface inheritance in reverse order to build the
-    # virtual function table, and leave out the 'object' base class.
-    for interface in itf.__mro__[-2::-1]:
+    for interface in _walk_itf_bases(itf):
         iids.append(interface._iid_)
         for m in interface._methods_:
-            restype, mthname, argtypes, paramflags, idlflags, helptext = m
-            proto = WINFUNCTYPE(restype, c_void_p, *argtypes)
-            fields.append((mthname, proto))
-            mth = finder.get_impl(interface, mthname, paramflags, idlflags)
+            proto = WINFUNCTYPE(m.restype, c_void_p, *m.argtypes)
+            fields.append((m.name, proto))
+            mth = finder.get_impl(interface, m.name, m.paramflags, m.idlflags)
             methods.append(proto(mth))
     Vtbl = _create_vtbl_type(tuple(fields), itf)
     vtbl = Vtbl(*methods)
     return (iids, vtbl)
 
 
+def _walk_itf_bases(itf: Type[IUnknown]) -> Iterator[Type[IUnknown]]:
+    """Iterates over interface inheritance in reverse order to build the
+    virtual function table, and leave out the 'object' base class.
+    """
+    yield from itf.__mro__[-2::-1]
+
+
 def create_dispimpl(
     itf: Type[IUnknown], finder: _MethodFinder
-) -> Dict[Tuple[int, int], Callable[..., Any]]:
-    dispimpl: Dict[Tuple[int, int], Callable[..., Any]] = {}
+) -> Dict[Tuple[comtypes.dispid, int], Callable[..., Any]]:
+    dispimpl: Dict[Tuple[comtypes.dispid, int], Callable[..., Any]] = {}
     for m in itf._disp_methods_:
         #################
         # What we have:
@@ -374,13 +375,6 @@ def create_dispimpl(
         #
         # paramflags must be a sequence
         # of (F_IN|F_OUT|F_RETVAL, paramname[, default-value]) tuples
-        #
-        # comtypes has this function which helps:
-        #    def _encode_idl(names):
-        #        # convert to F_xxx and sum up "in", "out",
-        #        # "retval" values found in _PARAMFLAGS, ignoring
-        #        # other stuff.
-        #        return sum([_PARAMFLAGS.get(n, 0) for n in names])
         #################
 
         if m.what == "DISPMETHOD":
@@ -392,37 +386,40 @@ def create_dispimpl(
 
 def _make_dispmthentry(
     itf: Type[IUnknown], finder: _MethodFinder, m: "_DispMemberSpec"
-) -> Iterator[Tuple[Tuple[int, int], Callable[..., Any]]]:
-    _, mthname, idlflags, restype, argspec = m
-    if "propget" in idlflags:
+) -> Iterator[Tuple[Tuple[comtypes.dispid, int], Callable[..., Any]]]:
+    if "propget" in m.idlflags:
         invkind = DISPATCH_PROPERTYGET
-        mthname = f"_get_{mthname}"
-    elif "propput" in idlflags:
+        mthname = f"_get_{m.name}"
+    elif "propput" in m.idlflags:
         invkind = DISPATCH_PROPERTYPUT
-        mthname = f"_set_{mthname}"
-    elif "propputref" in idlflags:
+        mthname = f"_set_{m.name}"
+    elif "propputref" in m.idlflags:
         invkind = DISPATCH_PROPERTYPUTREF
-        mthname = f"_setref_{mthname}"
+        mthname = f"_setref_{m.name}"
     else:
         invkind = DISPATCH_METHOD
-        if restype:
-            argspec = argspec + ((["out"], restype, ""),)
-    yield from _make_dispentry(finder, itf, mthname, idlflags, argspec, invkind)
+        if m.restype:
+            argspec = m.argspec + ((["out"], m.restype, ""),)
+        else:
+            argspec = m.argspec
+        mthname = m.name
+    yield from _make_dispentry(finder, itf, mthname, m.idlflags, argspec, invkind)
 
 
 def _make_disppropentry(
     itf: Type[IUnknown], finder: _MethodFinder, m: "_DispMemberSpec"
-) -> Iterator[Tuple[Tuple[int, int], Callable[..., Any]]]:
-    _, mthname, idlflags, restype, argspec = m
-    # DISPPROPERTY have implicit "out"
-    if restype:
-        argspec += ((["out"], restype, ""),)
+) -> Iterator[Tuple[Tuple[comtypes.dispid, int], Callable[..., Any]]]:
+    if m.restype:
+        # DISPPROPERTY have implicit "out"
+        argspec = m.argspec + ((["out"], m.restype, ""),)
+    else:
+        argspec = m.argspec
     yield from _make_dispentry(
-        finder, itf, f"_get_{mthname}", idlflags, argspec, DISPATCH_PROPERTYGET
+        finder, itf, f"_get_{m.name}", m.idlflags, argspec, DISPATCH_PROPERTYGET
     )
-    if "readonly" not in idlflags:
+    if "readonly" not in m.idlflags:
         yield from _make_dispentry(
-            finder, itf, f"_set_{mthname}", idlflags, argspec, DISPATCH_PROPERTYPUT
+            finder, itf, f"_set_{m.name}", m.idlflags, argspec, DISPATCH_PROPERTYPUT
         )
         # Add DISPATCH_PROPERTYPUTREF also?
 
@@ -431,10 +428,10 @@ def _make_dispentry(
     finder: _MethodFinder,
     interface: Type[IUnknown],
     mthname: str,
-    idlflags: Tuple[_UnionT[str, int], ...],
-    argspec: Tuple["_ArgSpecElmType", ...],
+    idlflags: "_DispIdlFlags",
+    argspec: Tuple["hints.ArgSpecElmType", ...],
     invkind: int,
-) -> Iterator[Tuple[Tuple[int, int], Callable[..., Any]]]:
+) -> Iterator[Tuple[Tuple[comtypes.dispid, int], Callable[..., Any]]]:
     # We build a _dispmap_ entry now that maps invkind and dispid to
     # implementations that the finder finds; IDispatch_Invoke will later call it.
     paramflags = tuple(((_encode_idl(x[0]), x[1]) + tuple(x[3:])) for x in argspec)

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/automation.py

@@ -11,12 +11,16 @@ from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Type
 
 import comtypes
 import comtypes.patcher
-from comtypes import BSTR, COMMETHOD, GUID, IID, STDMETHOD, IUnknown, _CData, _safearray
+from comtypes import BSTR, COMMETHOD, GUID, IID, STDMETHOD, IUnknown, _safearray
 from comtypes import hresult as hresult
+from comtypes._memberspec import DISPATCH_METHOD as DISPATCH_METHOD
+from comtypes._memberspec import DISPATCH_PROPERTYGET as DISPATCH_PROPERTYGET
+from comtypes._memberspec import DISPATCH_PROPERTYPUT as DISPATCH_PROPERTYPUT
+from comtypes._memberspec import DISPATCH_PROPERTYPUTREF as DISPATCH_PROPERTYPUTREF
 from comtypes.safearray import _midlSAFEARRAY
 
 if TYPE_CHECKING:
-    from ctypes import _CArgObject
+    from ctypes import _CArgObject, _CDataType
 
     from comtypes import hints  # type: ignore
     from comtypes._memberspec import _DispMemberSpec
@@ -30,11 +34,6 @@ SCODE = LONG
 
 VARTYPE = c_ushort
 
-DISPATCH_METHOD = 1
-DISPATCH_PROPERTYGET = 2
-DISPATCH_PROPERTYPUT = 4
-DISPATCH_PROPERTYPUTREF = 8
-
 tagINVOKEKIND = c_int
 INVOKE_FUNC = DISPATCH_METHOD
 INVOKE_PROPERTYGET = DISPATCH_PROPERTYGET
@@ -575,23 +574,29 @@ class tagVARIANT(Structure):
 VARIANT = tagVARIANT
 VARIANTARG = VARIANT
 
+_oleaut32_nohresult = WinDLL("oleaut32")
+
+_SysAllocStringLen = _oleaut32_nohresult.SysAllocStringLen
+_SysAllocStringLen.argtypes = c_wchar_p, c_uint
+_SysAllocStringLen.restype = c_void_p
+
 _oleaut32 = OleDLL("oleaut32")
 
 _VariantChangeType = _oleaut32.VariantChangeType
 _VariantChangeType.argtypes = (POINTER(VARIANT), POINTER(VARIANT), c_ushort, VARTYPE)
+_VariantChangeType.restype = HRESULT
 
 _VariantClear = _oleaut32.VariantClear
 _VariantClear.argtypes = (POINTER(VARIANT),)
-
-_SysAllocStringLen = windll.oleaut32.SysAllocStringLen
-_SysAllocStringLen.argtypes = c_wchar_p, c_uint
-_SysAllocStringLen.restype = c_void_p
+_VariantClear.restype = HRESULT
 
 _VariantCopy = _oleaut32.VariantCopy
 _VariantCopy.argtypes = POINTER(VARIANT), POINTER(VARIANT)
+_VariantCopy.restype = HRESULT
 
 _VariantCopyInd = _oleaut32.VariantCopyInd
 _VariantCopyInd.argtypes = POINTER(VARIANT), POINTER(VARIANT)
+_VariantCopyInd.restype = HRESULT
 
 # some commonly used VARIANT instances
 VARIANT.null = VARIANT(None)
@@ -872,7 +877,7 @@ class IDispatch(IUnknown):
         #     objects referred to by rgvarg[ ] or placed in *pVarResult.
         #
         # For comtypes this is handled in DISPPARAMS.__del__ and VARIANT.__del__.
-        _invkind = kw.pop("_invkind", 1)  # DISPATCH_METHOD
+        _invkind = kw.pop("_invkind", DISPATCH_METHOD)
         _lcid = kw.pop("_lcid", 0)
         if kw:
             raise ValueError("named parameters not yet implemented")
@@ -943,7 +948,7 @@ _arraycode_to_vartype = {
     "B": VT_UI1,
 }
 
-_ctype_to_vartype: Dict[Type[_CData], int] = {
+_ctype_to_vartype: Dict[Type["_CDataType"], int] = {
     c_byte: VT_I1,
     c_ubyte: VT_UI1,
     c_short: VT_I2,
@@ -980,7 +985,7 @@ _ctype_to_vartype: Dict[Type[_CData], int] = {
     # POINTER(IDispatch): VT_DISPATCH,
 }
 
-_vartype_to_ctype: Dict[int, Type[_CData]] = {}
+_vartype_to_ctype: Dict[int, Type["_CDataType"]] = {}
 for c, v in _ctype_to_vartype.items():
     _vartype_to_ctype[v] = c
 _vartype_to_ctype[VT_INT] = _vartype_to_ctype[VT_I4]

comtypes-1.4.11/comtypes/client/__init__.py

@@ -0,0 +1,42 @@
+"""comtypes.client - High level client level COM support package."""
+
+import ctypes
+import logging
+
+from comtypes import automation
+from comtypes.client import dynamic, lazybind  # noqa
+from comtypes.client._code_cache import _find_gen_dir
+from comtypes.client._constants import Constants  # noqa
+from comtypes.client._events import GetEvents, PumpEvents, ShowEvents
+from comtypes.client._generate import GetModule
+from comtypes.client._managing import GetBestInterface, _manage, wrap_outparam  # noqa
+from comtypes.hresult import *  # noqa
+
+gen_dir = _find_gen_dir()
+import comtypes.gen  # noqa
+
+### for testing
+##gen_dir = None
+
+logger = logging.getLogger(__name__)
+
+
+# backwards compatibility:
+wrap = GetBestInterface
+
+# Should we do this for POINTER(IUnknown) also?
+ctypes.POINTER(automation.IDispatch).__ctypes_from_outparam__ = wrap_outparam  # type: ignore
+
+from comtypes.client._activeobj import GetActiveObject
+from comtypes.client._create import (
+    CoGetObject,
+    CreateObject,
+    GetClassObject,
+)
+
+# fmt: off
+__all__ = [
+    "CreateObject", "GetActiveObject", "CoGetObject", "GetEvents",
+    "ShowEvents", "PumpEvents", "GetModule", "GetClassObject",
+]
+# fmt: on

comtypes-1.4.11/comtypes/client/_activeobj.py

@@ -0,0 +1,46 @@
+from typing import Any, Optional, Type, TypeVar, overload
+from typing import Union as _UnionT
+
+import comtypes
+import comtypes.client.dynamic
+from comtypes import GUID, CoClass, IUnknown, automation
+from comtypes.client._managing import _manage
+
+_T_IUnknown = TypeVar("_T_IUnknown", bound=IUnknown)
+
+
+################################################################
+#
+# Object creation
+#
+@overload
+def GetActiveObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any: ...
+@overload
+def GetActiveObject(
+    progid: _UnionT[str, Type[CoClass], GUID], interface: Type[_T_IUnknown]
+) -> _T_IUnknown: ...
+def GetActiveObject(
+    progid: _UnionT[str, Type[CoClass], GUID],
+    interface: Optional[Type[IUnknown]] = None,
+    dynamic: bool = False,
+) -> Any:
+    """Return a pointer to a running COM object that has been
+    registered with COM.
+
+    'progid' may be a string like "Excel.Application",
+       a string specifying a clsid, a GUID instance, or an object with
+       a _clsid_ attribute which should be any of the above.
+    'interface' allows to force a certain interface.
+    'dynamic=True' will return a dynamic dispatch object.
+    """
+    clsid = GUID.from_progid(progid)
+    if dynamic:
+        if interface is not None:
+            raise ValueError("interface and dynamic are mutually exclusive")
+        interface = automation.IDispatch
+    elif interface is None:
+        interface = getattr(progid, "_com_interfaces_", [None])[0]
+    obj = comtypes.GetActiveObject(clsid, interface=interface)
+    if dynamic:
+        return comtypes.client.dynamic.Dispatch(obj)
+    return _manage(obj, clsid, interface=interface)

{comtypes-1.4.9 → comtypes-1.4.11}/comtypes/client/_code_cache.py

@@ -5,8 +5,15 @@ comtypes.gen package and returns a directory where generated code can
 be written to.
 """
 
-import ctypes, logging, os, sys, tempfile, types
-from ctypes import wintypes
+import ctypes
+import logging
+import os
+import sys
+import tempfile
+import types
+from ctypes.wintypes import BOOL, HWND, LPWSTR, MAX_PATH
+
+from comtypes import typeinfo
 
 logger = logging.getLogger(__name__)
 
@@ -49,14 +56,14 @@ def _find_gen_dir():
         # where generated modules are placed.
         ftype = getattr(sys, "frozen", None)
         pymaj, pymin = sys.version_info[:2]
-        if ftype == None:
+        if ftype is None:
             # Python script
             subdir = rf"Python\Python{pymaj:d}{pymin:d}\comtypes_cache"
             basedir = _get_appdata_dir()
 
         elif ftype == "dll":
             # dll created with py2exe
-            path = _get_module_filename(sys.frozendllhandle)
+            path = typeinfo.GetModuleFileName(sys.frozendllhandle, MAX_PATH)
             base = os.path.splitext(os.path.basename(path))[0]
             subdir = rf"comtypes_cache\{base}-{pymaj:d}{pymin:d}"
             basedir = tempfile.gettempdir()
@@ -79,19 +86,12 @@ def _find_gen_dir():
 
 ################################################################
 
-SHGetSpecialFolderPath = ctypes.OleDLL("shell32.dll").SHGetSpecialFolderPathW
-GetModuleFileName = ctypes.WinDLL("kernel32.dll").GetModuleFileNameW
-SHGetSpecialFolderPath.argtypes = [
-    ctypes.c_ulong,
-    ctypes.c_wchar_p,
-    ctypes.c_int,
-    ctypes.c_int,
-]
-GetModuleFileName.restype = ctypes.c_ulong
-GetModuleFileName.argtypes = [wintypes.HMODULE, ctypes.c_wchar_p, ctypes.c_ulong]
+_shell32 = ctypes.OleDLL("shell32.dll")
+SHGetSpecialFolderPath = _shell32.SHGetSpecialFolderPathW
+SHGetSpecialFolderPath.argtypes = [HWND, LPWSTR, ctypes.c_int, BOOL]
+SHGetSpecialFolderPath.restype = BOOL
 
 CSIDL_APPDATA = 26
-MAX_PATH = 260
 
 
 def _create_comtypes_gen_package():
@@ -132,15 +132,6 @@ def _is_writeable(path):
     return os.access(path[0], os.W_OK)
 
 
-def _get_module_filename(hmodule):
-    """Call the Windows GetModuleFileName function which determines
-    the path from a module handle."""
-    path = ctypes.create_unicode_buffer(MAX_PATH)
-    if GetModuleFileName(hmodule, path, MAX_PATH):
-        return path.value
-    raise ctypes.WinError()
-
-
 def _get_appdata_dir():
     """Return the 'file system directory that serves as a common
     repository for application-specific data' - CSIDL_APPDATA"""