comtypes 1.4.10__zip → 1.4.12__zip

{comtypes-1.4.10 → comtypes-1.4.12}/comtypes/_post_coinit/unknwn.py

@@ -2,14 +2,19 @@
 
 import logging
 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, _CoUninitialize, 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__)
@@ -18,7 +23,7 @@ logger = logging.getLogger(__name__)
 def _shutdown(
     func=_CoUninitialize,
     _debug=logger.debug,
-):
+) -> None:
     # Sometimes, CoUninitialize, running at Python shutdown,
     # raises an exception.  We suppress this when __debug__ is
     # False.
@@ -28,7 +33,7 @@ def _shutdown(
     else:
         try:
             func()
-        except WindowsError:
+        except OSError:
             pass
     # Set the flag which means that calling obj.Release() is no longer
     # needed.
@@ -131,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
@@ -145,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_:
@@ -164,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.
@@ -197,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]:
@@ -216,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_)
@@ -261,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
@@ -275,40 +283,39 @@ 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
-        return (
-            super(_compointer_base, self).value == super(_compointer_base, other).value
-        )
+        return super().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)
+        return hash(super().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):
-        ptr = super(_compointer_base, self).value
+    def __repr__(self) -> str:
+        ptr = super().value
         return f"<{self.__class__.__name__} ptr=0x{ptr or 0:x} at {id(self):x}>"
 
     # This fixes the problem when there are multiple python interface types
     # 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
@@ -322,9 +329,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.10 → comtypes-1.4.12}/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]:
@@ -96,7 +93,7 @@ def catch_errors(
         except comtypes.ReturnHRESULT as err:
             (hr, text) = err.args
             return ReportError(text, iid=interface._iid_, clsid=clsid, hresult=hr)
-        except (COMError, WindowsError) as details:
+        except (OSError, COMError) as details:
             _error(
                 "Exception in %s.%s implementation:",
                 interface.__name__,
@@ -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]:
@@ -204,7 +201,7 @@ def hack(
                 msg = f"{source}: {descr}"
             hr = HRESULT_FROM_WIN32(hr)
             return ReportError(msg, iid=interface._iid_, clsid=clsid, hresult=hr)
-        except WindowsError as details:
+        except OSError as details:
             _error(
                 "Exception in %s.%s implementation:",
                 interface.__name__,
@@ -231,7 +228,7 @@ def hack(
     return call_without_this
 
 
-class _MethodFinder(object):
+class _MethodFinder:
     def __init__(self, inst: "hints.COMObject") -> None:
         self.inst = inst
         # map lower case names to names with correct spelling.
@@ -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.10 → comtypes-1.4.12}/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
@@ -246,9 +245,6 @@ class tagVARIANT(Structure):
         elif isinstance(value, bool):
             self.vt = VT_BOOL
             self._.VT_BOOL = value
-        elif isinstance(value, (int, c_int)):
-            self.vt = VT_I4
-            self._.VT_I4 = value
         elif isinstance(value, int):
             u = self._
             # try VT_I4 first.
@@ -265,12 +261,11 @@ class tagVARIANT(Structure):
                     self.vt = VT_UI4
                     return
             # try VT_I8 next.
-            if value >= 0:
-                u.VT_I8 = value
-                if u.VT_I8 == value:
-                    # did work.
-                    self.vt = VT_I8
-                    return
+            u.VT_I8 = value
+            if u.VT_I8 == value:
+                # did work.
+                self.vt = VT_I8
+                return
             # try VT_UI8 next.
             if value >= 0:
                 u.VT_UI8 = value
@@ -278,9 +273,7 @@ class tagVARIANT(Structure):
                     # did work.
                     self.vt = VT_UI8
                     return
-            # VT_R8 is last resort.
-            self.vt = VT_R8
-            u.VT_R8 = float(value)
+            raise TypeError(f"Cannot put {value!r} in VARIANT")
         elif isinstance(value, (float, c_double)):
             self.vt = VT_R8
             self._.VT_R8 = value
@@ -365,6 +358,9 @@ class tagVARIANT(Structure):
         elif isinstance(value, c_uint):
             self.vt = VT_UI4
             self._.VT_UI4 = value
+        elif isinstance(value, c_int):
+            self.vt = VT_I4
+            self._.VT_I4 = value
         elif isinstance(value, c_float):
             self.vt = VT_R4
             self._.VT_R4 = value
@@ -609,7 +605,7 @@ del v
 
 
 @comtypes.patcher.Patch(POINTER(VARIANT))
-class _(object):
+class _:
     # Override the default .from_param classmethod of POINTER(VARIANT).
     # This allows to pass values which can be stored in VARIANTs as
     # function parameters declared as POINTER(VARIANT).  See
@@ -878,7 +874,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")
@@ -949,7 +945,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,
@@ -986,7 +982,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.10 → comtypes-1.4.12}/comtypes/client/__init__.py

@@ -3,8 +3,9 @@
 import ctypes
 import logging
 
-from comtypes import automation
+from comtypes import RevokeActiveObject, automation  # noqa
 from comtypes.client import dynamic, lazybind  # noqa
+from comtypes.client._activeobj import RegisterActiveObject  # 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

{comtypes-1.4.10 → comtypes-1.4.12}/comtypes/client/_activeobj.py

@@ -44,3 +44,11 @@ def GetActiveObject(
     if dynamic:
         return comtypes.client.dynamic.Dispatch(obj)
     return _manage(obj, clsid, interface=interface)
+
+
+def RegisterActiveObject(
+    punk: IUnknown, progid: _UnionT[str, Type[CoClass], GUID], weak: bool = True
+) -> int:
+    clsid = GUID.from_progid(progid)
+    flags = comtypes.ACTIVEOBJECT_WEAK if weak else comtypes.ACTIVEOBJECT_STRONG
+    return comtypes.RegisterActiveObject(punk, clsid, flags)

{comtypes-1.4.10 → comtypes-1.4.12}/comtypes/client/_code_cache.py

@@ -11,7 +11,9 @@ import os
 import sys
 import tempfile
 import types
-from ctypes import wintypes
+from ctypes.wintypes import BOOL, HWND, LPWSTR, MAX_PATH
+
+from comtypes import typeinfo
 
 logger = logging.getLogger(__name__)
 
@@ -54,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()
@@ -84,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():
@@ -120,7 +115,7 @@ def _create_comtypes_gen_package():
                 ofi = open(comtypes_init, "w")
                 ofi.write("# comtypes.gen package, directory for generated files.\n")
                 ofi.close()
-        except (OSError, IOError) as details:
+        except OSError as details:
             logger.info("Creating comtypes.gen package failed: %s", details)
             module = sys.modules["comtypes.gen"] = types.ModuleType("comtypes.gen")
             comtypes.gen = module
@@ -137,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"""

{comtypes-1.4.10 → comtypes-1.4.12}/comtypes/client/_constants.py

@@ -43,7 +43,7 @@ class _frozen_attr_dict(dict):
         raise TypeError
 
 
-class Constants(object):
+class Constants:
     """This class loads the type library from the supplied object,
     then exposes constants and enumerations in the type library
     as attributes.