comtypes 1.4.7__zip → 1.4.9__zip

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/client/__init__.py

@@ -138,22 +138,17 @@ wrap = GetBestInterface
 # Should we do this for POINTER(IUnknown) also?
 ctypes.POINTER(automation.IDispatch).__ctypes_from_outparam__ = wrap_outparam  # type: ignore
 
+
 ################################################################
 #
 # Object creation
 #
 @overload
-def GetActiveObject(progid: _UnionT[str, CoClass, GUID]) -> Any:
-    ...
-
-
+def GetActiveObject(progid: _UnionT[str, CoClass, GUID]) -> Any: ...
 @overload
 def GetActiveObject(
     progid: _UnionT[str, CoClass, GUID], interface: Type[_T_IUnknown]
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def GetActiveObject(
     progid: _UnionT[str, CoClass, GUID],
     interface: Optional[Type[IUnknown]] = None,
@@ -193,14 +188,19 @@ def _manage(
 if TYPE_CHECKING:
 
     @overload
-    def GetClassObject(progid, clsctx=None, pServerInfo=None):
-        # type: (_UnionT[str, CoClass, GUID], Optional[int], Optional[comtypes.COSERVERINFO]) -> hints.IClassFactory
-        pass
-
+    def GetClassObject(
+        progid: _UnionT[str, CoClass, GUID],
+        clsctx: Optional[int] = None,
+        pServerInfo: Optional[comtypes.COSERVERINFO] = None,
+        interface: None = None,
+    ) -> hints.IClassFactory: ...
     @overload
-    def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
-        # type: (_UnionT[str, CoClass, GUID], Optional[int], Optional[comtypes.COSERVERINFO], Optional[Type[_T_IUnknown]]) -> _T_IUnknown
-        pass
+    def GetClassObject(
+        progid: _UnionT[str, CoClass, GUID],
+        clsctx: Optional[int] = None,
+        pServerInfo: Optional[comtypes.COSERVERINFO] = None,
+        interface: Type[_T_IUnknown] = hints.IClassFactory,
+    ) -> _T_IUnknown: ...
 
 
 def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
@@ -216,10 +216,7 @@ def GetClassObject(progid, clsctx=None, pServerInfo=None, interface=None):
 
 
 @overload
-def CreateObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any:
-    ...
-
-
+def CreateObject(progid: _UnionT[str, Type[CoClass], GUID]) -> Any: ...
 @overload
 def CreateObject(
     progid: _UnionT[str, Type[CoClass], GUID],
@@ -228,10 +225,7 @@ def CreateObject(
     interface: Optional[Type[_T_IUnknown]] = None,
     dynamic: bool = ...,
     pServerInfo: Optional[comtypes.COSERVERINFO] = None,
-) -> _T_IUnknown:
-    ...
-
-
+) -> _T_IUnknown: ...
 def CreateObject(
     progid: _UnionT[str, Type[CoClass], GUID],  # which object to create
     clsctx: Optional[int] = None,  # how to create the object
@@ -297,15 +291,11 @@ def CreateObject(
 
 
 @overload
-def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown:
-    ...
-
-
+def CoGetObject(displayname: str, interface: Type[_T_IUnknown]) -> _T_IUnknown: ...
 @overload
-def CoGetObject(displayname: str, interface: None = None, dynamic: bool = False) -> Any:
-    ...
-
-
+def CoGetObject(
+    displayname: str, interface: None = None, dynamic: bool = False
+) -> Any: ...
 def CoGetObject(
     displayname: str,
     interface: Optional[Type[comtypes.IUnknown]] = None,

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

@@ -4,6 +4,7 @@ The main function is _find_gen_dir(), which on-demand creates the
 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
 
@@ -47,23 +48,23 @@ def _find_gen_dir():
         # check type of executable image to determine a subdirectory
         # where generated modules are placed.
         ftype = getattr(sys, "frozen", None)
-        version_str = "%d%d" % sys.version_info[:2]
+        pymaj, pymin = sys.version_info[:2]
         if ftype == None:
             # Python script
-            subdir = r"Python\Python%s\comtypes_cache" % version_str
+            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)
             base = os.path.splitext(os.path.basename(path))[0]
-            subdir = r"comtypes_cache\%s-%s" % (base, version_str)
+            subdir = rf"comtypes_cache\{base}-{pymaj:d}{pymin:d}"
             basedir = tempfile.gettempdir()
 
         else:  # ftype in ('windows_exe', 'console_exe')
             # exe created by py2exe
             base = os.path.splitext(os.path.basename(sys.executable))[0]
-            subdir = r"comtypes_cache\%s-%s" % (base, version_str)
+            subdir = rf"comtypes_cache\{base}-{pymaj:d}{pymin:d}"
             basedir = tempfile.gettempdir()
 
         gen_dir = os.path.join(basedir, subdir)

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/client/_constants.py

@@ -118,7 +118,7 @@ class Constants(object):
                     # XXX is necessary warning? should use logging?
                     # import comtypes.tools
                     # if comtypes.tools.__warn_on_munge__:
-                    #     print("# Fixing keyword as VAR_CONST for %s" % name)
+                    #     print(f"# Fixing keyword as VAR_CONST for {name}")
                     name += "_"
                 members[name] = vdesc._.lpvarValue[0].value
         return _frozen_attr_dict(members)

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/client/_events.py

@@ -1,4 +1,3 @@
-from __future__ import print_function
 import ctypes
 import traceback
 import comtypes
@@ -228,7 +227,7 @@ class EventDumper(object):
         def handler(self, this, *args, **kw):
             # XXX handler is called with 'this'.  Should we really print "None" instead?
             args = (None,) + args
-            print("Event %s(%s)" % (name, ", ".join([repr(a) for a in args])))
+            print(f"Event {name}({', '.join([repr(a) for a in args])})")
 
         return comtypes.instancemethod(handler, self, EventDumper)
 

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/client/_generate.py

@@ -1,4 +1,3 @@
-from __future__ import print_function
 import ctypes
 import importlib
 import inspect
@@ -106,7 +105,8 @@ def GetModule(tlib: _UnionT[Any, typeinfo.ITypeLib]) -> types.ModuleType:
         frame = sys._getframe(1)
         _file_: Optional[str] = frame.f_globals.get("__file__", None)
         pathname, is_abs = _resolve_filename(
-            tlib_string, _file_ and os.path.dirname(_file_)  # type: ignore
+            tlib_string,
+            _file_ and os.path.dirname(_file_),  # type: ignore
         )
         logger.debug("GetModule(%s), resolved: %s", pathname, is_abs)
         tlib = _load_tlib(pathname)  # don't register
@@ -139,20 +139,16 @@ def _load_tlib(obj: Any) -> typeinfo.ITypeLib:
     elif isinstance(obj, GUID):
         clsid = str(obj)
         # lookup associated typelib in registry
-        with winreg.OpenKey(
-            winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\TypeLib" % clsid
-        ) as key:
+        with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}\TypeLib") as key:
             libid = winreg.EnumValue(key, 0)[1]
-        with winreg.OpenKey(
-            winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\Version" % clsid
-        ) as key:
+        with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"CLSID\{clsid}\Version") as key:
             ver = winreg.EnumValue(key, 0)[1].split(".")
         return typeinfo.LoadRegTypeLib(GUID(libid), int(ver[0]), int(ver[1]), 0)
     # obj is a sequence containing libid
     elif isinstance(obj, (tuple, list)):
         libid, ver = obj[0], obj[1:]
         if not ver:  # case of version numbers are not containing
-            with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"TypeLib\%s" % libid) as key:
+            with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, rf"TypeLib\{libid}") as key:
                 ver = [int(v, base=16) for v in winreg.EnumKey(key, 0).split(".")]
         return typeinfo.LoadRegTypeLib(GUID(libid), *ver)
     # obj is a COMObject implementation
@@ -161,7 +157,7 @@ def _load_tlib(obj: Any) -> typeinfo.ITypeLib:
     # obj is a pointer of ITypeLib
     elif isinstance(obj, ctypes.POINTER(typeinfo.ITypeLib)):
         return obj  # type: ignore
-    raise TypeError("'%r' is not supported type for loading typelib" % obj)
+    raise TypeError(f"'{obj!r}' is not supported type for loading typelib")
 
 
 def _get_existing_module(tlib: typeinfo.ITypeLib) -> Optional[types.ModuleType]:
@@ -251,9 +247,9 @@ _ItfName = str
 _ItfIid = str
 
 
-def _get_known_namespaces() -> Tuple[
-    Mapping[_SymbolName, _ModuleName], Mapping[_ItfName, _ItfIid]
-]:
+def _get_known_namespaces() -> (
+    Tuple[Mapping[_SymbolName, _ModuleName], Mapping[_ItfName, _ItfIid]]
+):
     """Returns symbols and interfaces that are already statically defined in `ctypes`
     and `comtypes`.
     From `ctypes`, all the names are obtained.

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/client/lazybind.py

@@ -67,7 +67,7 @@ class NamedProperty(object):
 
     def __iter__(self):
         """Explicitly disallow iteration."""
-        msg = "%r is not iterable" % self.disp
+        msg = f"{self.disp!r} is not iterable"
         raise TypeError(msg)
 
 
@@ -126,11 +126,6 @@ class Dispatch(object):
         "QueryInterface is forwarded to the real com object."
         return self._comobj.QueryInterface(*args)
 
-    def __cmp__(self, other):
-        if not isinstance(other, Dispatch):
-            return 1
-        return cmp(self._comobj, other._comobj)
-
     def __eq__(self, other):
         return isinstance(other, Dispatch) and self._comobj == other._comobj
 
@@ -156,7 +151,7 @@ class Dispatch(object):
                 if descr.cParams == 1:
                     return self._comobj._invoke(descr.memid, descr.invkind, 0)
             else:
-                raise RuntimeError("funckind %d not yet implemented" % descr.funckind)
+                raise RuntimeError(f"funckind {descr.funckind:d} not yet implemented")
             put = self.__bind(name, DISPATCH_PROPERTYPUT)
             putref = self.__bind(name, DISPATCH_PROPERTYPUTREF)
             return NamedProperty(self, descr, put, putref)

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/errorinfo.py

@@ -1,10 +1,10 @@
 import sys
 from ctypes import *
+from ctypes.wintypes import DWORD
 from comtypes import IUnknown, HRESULT, COMMETHOD, GUID, BSTR
 from comtypes.hresult import *
 
 LPCOLESTR = c_wchar_p
-DWORD = c_ulong
 
 
 class ICreateErrorInfo(IUnknown):
@@ -103,9 +103,9 @@ def ReportException(
             tb = tb.tb_next
         line = tb.tb_frame.f_lineno
         name = tb.tb_frame.f_globals["__name__"]
-        text = "%s: %s (%s, line %d)" % (typ, value, name, line)
+        text = f"{typ}: {value} ({name}, line {line:d})"
     else:
-        text = "%s: %s" % (typ, value)
+        text = f"{typ}: {value}"
     return ReportError(
         text,
         iid,

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/git.py

@@ -3,7 +3,9 @@
 The global interface table provides a way to marshal interface pointers
 between different threading appartments.
 """
+
 from ctypes import *
+from ctypes.wintypes import DWORD
 from comtypes import (
     IUnknown,
     STDMETHOD,
@@ -14,8 +16,6 @@ from comtypes import (
     CLSCTX_INPROC_SERVER,
 )
 
-DWORD = c_ulong
-
 
 class IGlobalInterfaceTable(IUnknown):
     _iid_ = GUID("{00000146-0000-0000-C000-000000000046}")

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/hints.pyi

@@ -3,17 +3,11 @@
 # - utilities for type hints.
 import ctypes
 import sys
-from typing import Any as Any, ClassVar, Generic, NoReturn, TypeVar, overload
+from typing import Any as Any, ClassVar, Generic, NoReturn, Protocol, TypeVar, overload
 from typing import Optional, Union as _UnionT
-from typing import List, Tuple as Tuple, Type
+from typing import Tuple as Tuple, Type
 from typing import Callable, Iterator, Sequence
 
-if sys.version_info >= (3, 8):
-    from typing import Protocol
-    from typing import Literal as Literal
-else:
-    from typing_extensions import Protocol
-    from typing_extensions import Literal as Literal
 if sys.version_info >= (3, 9):
     from typing import Annotated as Annotated
 else:
@@ -30,10 +24,11 @@ else:
     from typing_extensions import Self as Self
 
 import comtypes
-from comtypes import IUnknown as IUnknown, GUID as GUID
+from comtypes import IUnknown as IUnknown, COMObject as COMObject, GUID as GUID
 from comtypes.automation import IDispatch as IDispatch, VARIANT as VARIANT
 from comtypes.server import IClassFactory as IClassFactory
-from comtypes.typeinfo import ITypeInfo as ITypeInfo
+from comtypes.server import localserver as localserver
+from comtypes.typeinfo import ITypeInfo as ITypeInfo, ITypeLib as ITypeLib
 from comtypes._safearray import tagSAFEARRAY as tagSAFEARRAY
 
 Incomplete: TypeAlias = Any
@@ -74,6 +69,8 @@ class LP_SAFEARRAY(ctypes._Pointer[tagSAFEARRAY], Generic[_CT]):
     def unpack(self: LP_SAFEARRAY[_T_Struct]) -> Sequence[_T_Struct]: ...
     @overload
     def unpack(self) -> Sequence[Any]: ...
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self: ...
 
 _T_coclass = TypeVar("_T_coclass", bound=comtypes.CoClass)
 
@@ -85,11 +82,6 @@ class FirstComItfOf(Generic[_T_coclass]):
     as an argument.
     """
 
-class _MethodTypeDesc(Protocol):
-    arguments: List[Tuple[Any, str, List[str], Optional[Any]]]
-    idlflags: List[str]
-    name: str
-
 _P_Put = ParamSpec("_P_Put")
 _R_Put = TypeVar("_R_Put")
 _P_PutRef = ParamSpec("_P_PutRef")
@@ -253,7 +245,7 @@ _T_E = TypeVar("_T_E")
 def to_dunder_iter(
     newenum: _UnionT[
         _Descriptor[_T_Inst, Iterator[_T_E]], Callable[[_T_Inst], Iterator[_T_E]]
-    ]
+    ],
 ) -> Callable[[_T_Inst], Iterator[_T_E]]: ...
 @overload
 def to_dunder_iter(newenum: Any) -> Callable[..., NoReturn]: ...
@@ -266,7 +258,7 @@ def to_dunder_call(
         _GetSetNamedProperty[_T_Inst, _P_Get, _R_Get, ...],
         _GetOnlyNamedProperty[_T_Inst, _P_Get, _R_Get],
         Callable[Concatenate[_T_Inst, _P_Get], _R_Get],
-    ]
+    ],
 ) -> Callable[Concatenate[_T_Inst, _P_Get], _R_Get]: ...
 @overload
 def to_dunder_call(item: Any) -> Callable[..., NoReturn]: ...
@@ -278,7 +270,7 @@ def to_dunder_getitem(
         _GetSetNamedProperty[_T_Inst, _P_Get, _R_Get, ...],
         _GetOnlyNamedProperty[_T_Inst, _P_Get, _R_Get],
         Callable[Concatenate[_T_Inst, _P_Get], _R_Get],
-    ]
+    ],
 ) -> Callable[Concatenate[_T_Inst, _P_Get], _R_Get]: ...
 @overload
 def to_dunder_getitem(item: Any) -> Callable[..., NoReturn]: ...
@@ -289,7 +281,7 @@ def to_dunder_setitem(
     item: _UnionT[
         _GetSetNamedProperty[_T_Inst, ..., Any, _P_Set],
         _SetOnlyNamedProperty[_T_Inst, _P_Set],
-    ]
+    ],
 ) -> Callable[Concatenate[_T_Inst, _P_Set], Any]: ...
 @overload
 def to_dunder_setitem(item: Any) -> Callable[..., NoReturn]: ...

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/persist.py

@@ -9,6 +9,7 @@
 The 'DictPropertyBag' class is a class implementing the IPropertyBag
 interface, useful in client code.
 """
+
 from ctypes import c_int, c_ulong, c_ushort, c_wchar_p
 from ctypes import POINTER, Structure
 from ctypes.wintypes import WORD, DWORD, BOOL
@@ -244,13 +245,12 @@ class IPersistFile(IPersist):
     ]
 
     if TYPE_CHECKING:
-        # fmt: off
-        def IsDirty(self) -> hints.Hresult: ...  # noqa
-        def Load(self, pszFileName: str, dwMode: int) -> hints.Hresult: ...  # noqa
-        def Save(self, pszFileName: str, fRemember: bool) -> hints.Hresult: ...  # noqa
-        def SaveCompleted(self, pszFileName: str) -> hints.Hresult: ...  # noqa
-        def GetCurFile(self) -> str: ...  # noqa
-        # fmt: on
+
+        def IsDirty(self) -> hints.Hresult: ...
+        def Load(self, pszFileName: str, dwMode: int) -> hints.Hresult: ...
+        def Save(self, pszFileName: str, fRemember: bool) -> hints.Hresult: ...
+        def SaveCompleted(self, pszFileName: str) -> hints.Hresult: ...
+        def GetCurFile(self) -> str: ...
 
 
 from comtypes import COMObject

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/safearray.py

@@ -78,12 +78,11 @@ def _make_safearray_type(itemtype):
         VT_UNKNOWN,
         IDispatch,
         VT_DISPATCH,
+        VT_HRESULT,
     )
 
     meta = type(_safearray.tagSAFEARRAY)
-    sa_type = meta.__new__(
-        meta, "SAFEARRAY_%s" % itemtype.__name__, (_safearray.tagSAFEARRAY,), {}
-    )
+    sa_type = meta(f"SAFEARRAY_{itemtype.__name__}", (_safearray.tagSAFEARRAY,), {})
 
     try:
         vartype = _ctype_to_vartype[itemtype]
@@ -125,6 +124,15 @@ def _make_safearray_type(itemtype):
             one-dimensional arrays.  To create multidimensional arrys,
             numpy arrays must be passed.
             """
+            if cls._vartype_ == VT_HRESULT:
+                raise TypeError(
+                    # There are COM type libraries that define the
+                    # `_midlSAFEARRAY(HRESULT)` type; however, creating `HRESULT`
+                    # safearray pointer instance does not work.
+                    # See also: https://github.com/enthought/comtypes/issues/668
+                    "Cannot create SAFEARRAY type VT_HRESULT."
+                )
+
             if comtypes.npsupport.isndarray(value):
                 return cls.create_from_ndarray(value, extra)
 
@@ -192,9 +200,7 @@ def _make_safearray_type(itemtype):
                 nitems *= d
                 rgsa[i].cElements = d
                 rgsa[i].lBound = lBound
-            pa = _safearray.SafeArrayCreateEx(
-                cls._vartype_, value.ndim, rgsa, extra  # cDims  # rgsaBound
-            )  # pvExtra
+            pa = _safearray.SafeArrayCreateEx(cls._vartype_, value.ndim, rgsa, extra)
             if not pa:
                 if cls._vartype_ == VT_RECORD and extra is None:
                     raise TypeError(

comtypes-1.4.9/comtypes/server/__init__.py

@@ -0,0 +1,86 @@
+import ctypes
+from ctypes import HRESULT, POINTER, byref
+from typing import TYPE_CHECKING, Any, Optional, Type
+
+import comtypes
+import comtypes.client
+import comtypes.client.dynamic
+from comtypes import GUID, STDMETHOD, IUnknown
+from comtypes.automation import IDispatch
+
+if TYPE_CHECKING:
+    from ctypes import _Pointer
+
+    from comtypes import hints  # type: ignore
+
+
+################################################################
+# Interfaces
+class IClassFactory(IUnknown):
+    _iid_ = GUID("{00000001-0000-0000-C000-000000000046}")
+    _methods_ = [
+        STDMETHOD(
+            HRESULT,
+            "CreateInstance",
+            [POINTER(IUnknown), POINTER(GUID), POINTER(ctypes.c_void_p)],
+        ),
+        STDMETHOD(HRESULT, "LockServer", [ctypes.c_int]),
+    ]
+
+    def CreateInstance(
+        self,
+        punkouter: Optional[Type["_Pointer[IUnknown]"]] = None,
+        interface: Optional[Type[IUnknown]] = None,
+        dynamic: bool = False,
+    ) -> Any:
+        if dynamic:
+            if interface is not None:
+                raise ValueError("interface and dynamic are mutually exclusive")
+            itf = IDispatch
+        elif interface is None:
+            itf = IUnknown
+        else:
+            itf = interface
+        obj = POINTER(itf)()
+        self.__com_CreateInstance(punkouter, itf._iid_, byref(obj))  # type: ignore
+        if dynamic:
+            return comtypes.client.dynamic.Dispatch(obj)
+        elif interface is None:
+            # An interface was not specified, so return the best.
+            return comtypes.client.GetBestInterface(obj)
+        # An interface was specified and obj is already that interface.
+        return obj
+
+    if TYPE_CHECKING:
+
+        def LockServer(self, fLock: int) -> hints.Hresult: ...
+
+
+# class IExternalConnection(IUnknown):
+#     _iid_ = GUID("{00000019-0000-0000-C000-000000000046}")
+#     _methods_ = [
+#         STDMETHOD(HRESULT, "AddConnection", [c_ulong, c_ulong]),
+#         STDMETHOD(HRESULT, "ReleaseConnection", [c_ulong, c_ulong, c_ulong])]
+
+# The following code is untested:
+
+ACTIVEOBJECT_STRONG = 0x0
+ACTIVEOBJECT_WEAK = 0x1
+
+oleaut32 = ctypes.oledll.oleaut32
+
+
+def RegisterActiveObject(comobj: comtypes.COMObject, weak: bool = True) -> int:
+    punk = comobj._com_pointers_[IUnknown._iid_]
+    clsid = comobj._reg_clsid_
+    if weak:
+        flags = ACTIVEOBJECT_WEAK
+    else:
+        flags = ACTIVEOBJECT_STRONG
+    handle = ctypes.c_ulong()
+    oleaut32.RegisterActiveObject(punk, byref(clsid), flags, byref(handle))
+    return handle.value
+
+
+def RevokeActiveObject(handle: int) -> None:
+    oleaut32.RevokeActiveObject(handle, None)

{comtypes-1.4.7 → comtypes-1.4.9}/comtypes/server/inprocserver.py

@@ -1,12 +1,11 @@
 import ctypes
-from comtypes import COMObject, GUID
-from comtypes.server import IClassFactory
-from comtypes.hresult import *
-
-import sys
 import logging
+import sys
 import winreg
+from typing import Any, Literal, Optional, Type
 
+from comtypes import GUID, COMObject, IUnknown, hresult
+from comtypes.server import IClassFactory
 
 logger = logging.getLogger(__name__)
 _debug = logger.debug
@@ -18,33 +17,39 @@ _critical = logger.critical
 class ClassFactory(COMObject):
     _com_interfaces_ = [IClassFactory]
 
-    def __init__(self, cls):
+    def __init__(self, cls: Type[COMObject]) -> None:
         super(ClassFactory, self).__init__()
         self._cls = cls
 
-    def IClassFactory_CreateInstance(self, this, punkOuter, riid, ppv):
+    def IClassFactory_CreateInstance(
+        self,
+        this: Any,
+        punkOuter: Optional[Type["ctypes._Pointer[IUnknown]"]],
+        riid: "ctypes._Pointer[GUID]",
+        ppv: ctypes.c_void_p,
+    ) -> int:
         _debug("ClassFactory.CreateInstance(%s)", riid[0])
         result = self._cls().IUnknown_QueryInterface(None, riid, ppv)
         _debug("CreateInstance() -> %s", result)
         return result
 
-    def IClassFactory_LockServer(self, this, fLock):
+    def IClassFactory_LockServer(self, this: Any, fLock: bool) -> Literal[0]:
         if fLock:
             COMObject.__server__.Lock()
         else:
             COMObject.__server__.Unlock()
-        return S_OK
+        return hresult.S_OK
 
 
 # will be set by py2exe boot script 'from outside'
 _clsid_to_class = {}
 
 
-def inproc_find_class(clsid):
+def inproc_find_class(clsid: GUID) -> Type[COMObject]:
     if _clsid_to_class:
         return _clsid_to_class[clsid]
 
-    key = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, "CLSID\\%s\\InprocServer32" % clsid)
+    key = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, f"CLSID\\{clsid}\\InprocServer32")
     try:
         pathdir = winreg.QueryValueEx(key, "PythonPath")[0]
     except:
@@ -70,7 +75,7 @@ def inproc_find_class(clsid):
 _logging_configured = False
 
 
-def _setup_logging(clsid):
+def _setup_logging(clsid: GUID) -> None:
     """Read from the registry, and configure the logging module.
 
     Currently, the handler (NTDebugHandler) is hardcoded.
@@ -109,7 +114,7 @@ def _setup_logging(clsid):
         logging.getLogger(name).setLevel(level)
 
 
-def DllGetClassObject(rclsid, riid, ppv):
+def DllGetClassObject(rclsid: int, riid: int, ppv: int) -> int:
     COMObject.__run_inprocserver__()
 
     iid = GUID.from_address(riid)
@@ -127,7 +132,7 @@ def DllGetClassObject(rclsid, riid, ppv):
 
         cls = inproc_find_class(clsid)
         if not cls:
-            return CLASS_E_CLASSNOTAVAILABLE
+            return hresult.CLASS_E_CLASSNOTAVAILABLE
 
         result = ClassFactory(cls).IUnknown_QueryInterface(
             None, ctypes.pointer(iid), ctypes.c_void_p(ppv)
@@ -136,12 +141,12 @@ def DllGetClassObject(rclsid, riid, ppv):
         return result
     except Exception:
         _critical("DllGetClassObject", exc_info=True)
-        return E_FAIL
+        return hresult.E_FAIL
 
 
-def DllCanUnloadNow():
+def DllCanUnloadNow() -> Literal[1]:  # S_FALSE
     COMObject.__run_inprocserver__()
     result = COMObject.__server__.DllCanUnloadNow()
     # To avoid a memory leak when PyInitialize()/PyUninitialize() are
     # called several times, we refuse to unload the dll.
-    return S_FALSE
+    return hresult.S_FALSE