comtypes 1.4.1__zip → 1.4.3__zip

{comtypes-1.4.1 → comtypes-1.4.3}/CHANGES.txt

@@ -1,9 +1,32 @@
 Comtypes CHANGELOG
 ==================
 
+Release 1.4.3
+--------------
+* Refactor ``test_findgendir``. By @junkmd.
+* Update ``test_GUID``. By @junkmd.
+* Add a feature to ``typeannotator`` that interprets the return value. By @junkmd.
+* Update type annotations for ``_IUnknown_Base`` and ``IUnknown``. By @junkmd.
+* Add ``groupby_impltypeflags``. By @junkmd.
+* Add static typing for when a ``CoClass`` is assigned as the return value type. By @junkmd.
+* Improve ``EnumerationNamespaces`` and ``CodeGenerator.enum_aliases``. By @junkmd.
+* Modernize constructor arguments and attributes of each stuff in ``typedesc``. By @junkmd.
+* Split ``codegenerator`` into some modules in the sub-package directory. By @junkmd.
+* Implement record pointers as method parameters of a Dispatch Interface. By @geppi.
+* Add ``npsupport`` to CI pipeline matrix. By @junkmd.
+* Add "Frequently Asked Questions" to ``README.md``. By @junkmd.
+
+Release 1.4.2
+--------------
+* Improve the stability of module generation by ``GetModule``. By @junkmd.
+* Define ``c_int`` aliases earlier than others in wrapper modules. By @junkmd.
+* Remove trailing newlines generated by ``codegenerator`` and ``typeannotator``. By @junkmd.
+* Determine whether a interface is one of the known symbols not only by its name but also by using its iid. By @junkmd.
+* Add ``Incomplete`` and ``Hresult`` to ``hints.pyi``. By @junkmd.
+
 Release 1.4.1
 --------------
-* Fix `TypeError` when defining enumeration types
+* Fix ``TypeError`` when defining enumeration types. By @junkmd.
 
 Release 1.4.0
 --------------

{comtypes-1.4.1/comtypes.egg-info → comtypes-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.4.1
+Version: 1.4.3
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -75,6 +75,34 @@ This project and the maintainers of thousands of other packages are working with
 
 [Learn more](https://tidelift.com/subscription/pkg/pypi-comtypes?utm_source=pypi-comtypes&utm_medium=referral&utm_campaign=github).
 
+## Frequently Asked Questions
+
+### Q: Why does this package not support platforms other than Windows?
+**A:** [The Microsoft Component Object Model (COM)](https://learn.microsoft.com/en-us/windows/win32/com/com-technical-overview) is a technology that is unique to Windows and is not supported on other platforms.
+
+[The phrase _"COM is a platform-independent"_ in the MS documentation](https://learn.microsoft.com/en-us/windows/win32/com/component-object-model--com--portal) means that COM maintains compatibility across different versions of Windows, and does NOT imply that it is supported on Linux or Mac.
+
+As long as COM is not supported outside of Windows, this project does not plan to port to other platforms.
+
+### Q: Why does `cannot import name 'COMError' from '_ctypes'` error occur when using this package on platforms other than Windows?
+**A:** The [`_ctypes`](https://github.com/python/cpython/blob/main/Modules/_ctypes/_ctypes.c) is part of the internal implementation of the [`ctypes`](https://github.com/python/cpython/blob/main/Lib/ctypes/) standard library that exists for Python on all platforms.  
+However, `COMError` and COM-related features are implemented only in Python for Windows.
+
+In cross-platform software development, care must be taken to ensure that codebase dependent on `comtypes` does not execute in environments other than Windows.
+
+### Q: Despite a script that depends on `comtypes` having run successfully before, a error (`ImportError`, `NameError`, or `SyntaxError`) is raised now, and the same error occurs again and again.
+
+**A:** Executing `py -m comtypes.clear_cache` and then running the script again might resolve the problem.
+
+When `comtypes.client.GetModule` is called (either directly or indirectly), `comtypes` generates Python module files.  
+If Python is forced to terminate or crashes in the middle of file generation, the codebase written to the file becomes partial.  
+When Python tries to import this unexecutable partial codebase module, an error occurs.
+
+Executing `py -m comtypes.clear_cache` identifies the directories where the "cache module files" are stored and deletes them.  
+After deleting these partial modules and running the script again, `comtypes.client.GetModule` is called and executable modules are generated anew.
+
+However, if the script implementation does not use `comtypes.client.GetModule` or processes generated files, it may not be a solution.
+
 ## Documentation:
 
 The documentation is currently hosted on pythonhosted at:

{comtypes-1.4.1 → comtypes-1.4.3}/README.md

@@ -56,6 +56,34 @@ This project and the maintainers of thousands of other packages are working with
 
 [Learn more](https://tidelift.com/subscription/pkg/pypi-comtypes?utm_source=pypi-comtypes&utm_medium=referral&utm_campaign=github).
 
+## Frequently Asked Questions
+
+### Q: Why does this package not support platforms other than Windows?
+**A:** [The Microsoft Component Object Model (COM)](https://learn.microsoft.com/en-us/windows/win32/com/com-technical-overview) is a technology that is unique to Windows and is not supported on other platforms.
+
+[The phrase _"COM is a platform-independent"_ in the MS documentation](https://learn.microsoft.com/en-us/windows/win32/com/component-object-model--com--portal) means that COM maintains compatibility across different versions of Windows, and does NOT imply that it is supported on Linux or Mac.
+
+As long as COM is not supported outside of Windows, this project does not plan to port to other platforms.
+
+### Q: Why does `cannot import name 'COMError' from '_ctypes'` error occur when using this package on platforms other than Windows?
+**A:** The [`_ctypes`](https://github.com/python/cpython/blob/main/Modules/_ctypes/_ctypes.c) is part of the internal implementation of the [`ctypes`](https://github.com/python/cpython/blob/main/Lib/ctypes/) standard library that exists for Python on all platforms.  
+However, `COMError` and COM-related features are implemented only in Python for Windows.
+
+In cross-platform software development, care must be taken to ensure that codebase dependent on `comtypes` does not execute in environments other than Windows.
+
+### Q: Despite a script that depends on `comtypes` having run successfully before, a error (`ImportError`, `NameError`, or `SyntaxError`) is raised now, and the same error occurs again and again.
+
+**A:** Executing `py -m comtypes.clear_cache` and then running the script again might resolve the problem.
+
+When `comtypes.client.GetModule` is called (either directly or indirectly), `comtypes` generates Python module files.  
+If Python is forced to terminate or crashes in the middle of file generation, the codebase written to the file becomes partial.  
+When Python tries to import this unexecutable partial codebase module, an error occurs.
+
+Executing `py -m comtypes.clear_cache` identifies the directories where the "cache module files" are stored and deletes them.  
+After deleting these partial modules and running the script again, `comtypes.client.GetModule` is called and executable modules are generated anew.
+
+However, if the script implementation does not use `comtypes.client.GetModule` or processes generated files, it may not be a solution.
+
 ## Documentation:
 
 The documentation is currently hosted on pythonhosted at:

{comtypes-1.4.1 → comtypes-1.4.3}/comtypes/__init__.py

@@ -1,5 +1,5 @@
 # comtypes version numbers follow semver (http://semver.org/) and PEP 440
-__version__ = "1.4.1"
+__version__ = "1.4.3"
 
 import atexit
 from ctypes import *
@@ -774,7 +774,7 @@ _T_IUnknown = TypeVar("_T_IUnknown", bound="IUnknown")
 
 if TYPE_CHECKING:
 
-    class _IUnknown_Base(c_void_p, metaclass=_cominterface_meta):
+    class _IUnknown_Base(c_void_p, metaclass=_cominterface_meta):  # type: ignore
         """This is workaround to avoid false-positive of static type checking.
 
         `IUnknown` behaves as a ctypes type, and `POINTER` can take it.
@@ -784,9 +784,7 @@ if TYPE_CHECKING:
         `builtins.object`.
         """
 
-        __com_QueryInterface: Callable[[Any, Any], int]
-        __com_AddRef: Callable[[], int]
-        __com_Release: Callable[[], int]
+        ...
 
 else:
     _IUnknown_Base = object
@@ -825,7 +823,7 @@ class IUnknown(_IUnknown_Base, metaclass=_cominterface_meta):
         p = POINTER(interface)()
         if iid is None:
             iid = interface._iid_
-        self.__com_QueryInterface(byref(iid), byref(p))
+        self.__com_QueryInterface(byref(iid), byref(p))  # type: ignore
         clsid = self.__dict__.get("__clsid")
         if clsid is not None:
             p.__dict__["__clsid"] = clsid
@@ -835,11 +833,11 @@ class IUnknown(_IUnknown_Base, metaclass=_cominterface_meta):
     # XXX There should be other ways to install a docstring.
     def AddRef(self) -> int:
         """Increase the internal refcount by one and return it."""
-        return self.__com_AddRef()
+        return self.__com_AddRef()  # type: ignore
 
     def Release(self) -> int:
         """Decrease the internal refcount by one and return it."""
-        return self.__com_Release()
+        return self.__com_Release()  # type: ignore
 
 
 ################################################################

{comtypes-1.4.1 → comtypes-1.4.3}/comtypes/automation.py

@@ -393,12 +393,36 @@ class tagVARIANT(Structure):
             ref = value._obj
             self._.c_void_p = addressof(ref)
             self.__keepref = value
-            self.vt = _ctype_to_vartype[type(ref)] | VT_BYREF
+            if isinstance(ref, Structure) and hasattr(ref, "_recordinfo_"):
+                guids = ref._recordinfo_
+                from comtypes.typeinfo import GetRecordInfoFromGuids
+
+                ri = GetRecordInfoFromGuids(*guids)
+                self.vt = VT_RECORD | VT_BYREF
+                # Assigning a COM pointer to a structure field does NOT
+                # call AddRef(), have to call it manually:
+                ri.AddRef()
+                self._.pRecInfo = ri
+                self._.pvRecord = cast(value, c_void_p)
+            else:
+                self.vt = _ctype_to_vartype[type(ref)] | VT_BYREF
         elif isinstance(value, _Pointer):
             ref = value.contents
             self._.c_void_p = addressof(ref)
             self.__keepref = value
-            self.vt = _ctype_to_vartype[type(ref)] | VT_BYREF
+            if isinstance(ref, Structure) and hasattr(ref, "_recordinfo_"):
+                guids = ref._recordinfo_
+                from comtypes.typeinfo import GetRecordInfoFromGuids
+
+                ri = GetRecordInfoFromGuids(*guids)
+                self.vt = VT_RECORD | VT_BYREF
+                # Assigning a COM pointer to a structure field does NOT
+                # call AddRef(), have to call it manually:
+                ri.AddRef()
+                self._.pRecInfo = ri
+                self._.pvRecord = cast(value, c_void_p)
+            else:
+                self.vt = _ctype_to_vartype[type(ref)] | VT_BYREF
         else:
             raise TypeError("Cannot put %r in VARIANT" % value)
         # buffer ->  SAFEARRAY of VT_UI1 ?

{comtypes-1.4.1 → comtypes-1.4.3}/comtypes/client/_generate.py

@@ -1,11 +1,12 @@
 from __future__ import print_function
 import ctypes
 import importlib
+import inspect
 import logging
 import os
 import sys
 import types
-from typing import Any, Tuple, List, Optional, Dict, Union as _UnionT
+from typing import Any, Tuple, List, Mapping, Optional, Dict, Union as _UnionT
 import winreg
 
 from comtypes import GUID, typeinfo
@@ -121,7 +122,10 @@ def GetModule(tlib: _UnionT[Any, typeinfo.ITypeLib]) -> types.ModuleType:
         pathname = None
         tlib = _load_tlib(tlib)
     logger.debug("GetModule(%s)", tlib.GetLibAttr())
-    return ModuleGenerator().generate(tlib, pathname)
+    mod = _get_existing_module(tlib)
+    if mod is not None:
+        return mod
+    return ModuleGenerator(tlib, pathname).generate()
 
 
 def _load_tlib(obj: Any) -> typeinfo.ITypeLib:
@@ -160,94 +164,110 @@ def _load_tlib(obj: Any) -> typeinfo.ITypeLib:
     raise TypeError("'%r' is not supported type for loading typelib" % obj)
 
 
-def _create_module_in_file(modulename: str, code: str) -> types.ModuleType:
-    """create module in file system, and import it"""
+def _get_existing_module(tlib: typeinfo.ITypeLib) -> Optional[types.ModuleType]:
+    def _get_friendly(name: str) -> Optional[types.ModuleType]:
+        try:
+            mod = _my_import(name)
+        except Exception as details:
+            logger.info("Could not import %s: %s", friendly_name, details)
+        else:
+            return mod
+
+    def _get_wrapper(name: str) -> Optional[types.ModuleType]:
+        if name in sys.modules:
+            return sys.modules[name]
+        try:
+            return _my_import(name)
+        except Exception as details:
+            logger.info("Could not import %s: %s", name, details)
+
+    wrapper_name = codegenerator.name_wrapper_module(tlib)
+    friendly_name = codegenerator.name_friendly_module(tlib)
+    wrapper_module = _get_wrapper(wrapper_name)
+    if wrapper_module is not None:
+        if friendly_name is None:
+            return wrapper_module
+        else:
+            friendly_module = _get_friendly(friendly_name)
+            if friendly_module is not None:
+                return friendly_module
+    return None
+
+
+def _create_module(modulename: str, code: str) -> types.ModuleType:
+    """Creates the module, then imports it."""
     # `modulename` is 'comtypes.gen.xxx'
-    filename = "%s.py" % modulename.split(".")[-1]
-    with open(os.path.join(comtypes.client.gen_dir, filename), "w") as ofi:
+    stem = modulename.split(".")[-1]
+    if comtypes.client.gen_dir is None:
+        # in memory system
+        import comtypes.gen as g
+
+        mod = types.ModuleType(modulename)
+        abs_gen_path = os.path.abspath(g.__path__[0])  # type: ignore
+        mod.__file__ = os.path.join(abs_gen_path, "<memory>")
+        exec(code, mod.__dict__)
+        sys.modules[modulename] = mod
+        setattr(g, stem, mod)
+        return mod
+    # in file system
+    with open(os.path.join(comtypes.client.gen_dir, f"{stem}.py"), "w") as ofi:
         print(code, file=ofi)
     # clear the import cache to make sure Python sees newly created modules
-    if hasattr(importlib, "invalidate_caches"):
-        importlib.invalidate_caches()
+    importlib.invalidate_caches()
     return _my_import(modulename)
 
 
-def _create_module_in_memory(modulename: str, code: str) -> types.ModuleType:
-    """create module in memory system, and import it"""
-    # `modulename` is 'comtypes.gen.xxx'
-    import comtypes.gen as g
-
-    mod = types.ModuleType(modulename)
-    abs_gen_path = os.path.abspath(g.__path__[0])  # type: ignore
-    mod.__file__ = os.path.join(abs_gen_path, "<memory>")
-    exec(code, mod.__dict__)
-    sys.modules[modulename] = mod
-    setattr(g, modulename.split(".")[-1], mod)
-    return mod
-
-
 class ModuleGenerator(object):
-    def __init__(self) -> None:
-        self.codegen = codegenerator.CodeGenerator(_get_known_symbols())
-
-    def generate(
-        self, tlib: typeinfo.ITypeLib, pathname: Optional[str]
-    ) -> types.ModuleType:
-        # create and import the real typelib wrapper module
-        mod = self._create_wrapper_module(tlib, pathname)
-        # try to get the friendly-name, if not, returns the real typelib wrapper module
-        modulename = codegenerator.name_friendly_module(tlib)
-        if modulename is None:
-            return mod
-        # create and import the friendly-named module
-        return self._create_friendly_module(tlib, modulename)
-
-    def _create_friendly_module(
-        self, tlib: typeinfo.ITypeLib, modulename: str
-    ) -> types.ModuleType:
-        """helper which creates and imports the friendly-named module."""
-        try:
-            mod = _my_import(modulename)
-        except Exception as details:
-            logger.info("Could not import %s: %s", modulename, details)
-        else:
-            return mod
-        # the module is always regenerated if the import fails
-        logger.info("# Generating %s", modulename)
-        # determine the Python module name
-        modname = codegenerator.name_wrapper_module(tlib)
-        code = self.codegen.generate_friendly_code(modname)
-        if comtypes.client.gen_dir is None:
-            return _create_module_in_memory(modulename, code)
-        return _create_module_in_file(modulename, code)
-
-    def _create_wrapper_module(
-        self, tlib: typeinfo.ITypeLib, pathname: Optional[str]
-    ) -> types.ModuleType:
-        """helper which creates and imports the real typelib wrapper module."""
-        modulename = codegenerator.name_wrapper_module(tlib)
-        if modulename in sys.modules:
-            return sys.modules[modulename]
-        try:
-            return _my_import(modulename)
-        except Exception as details:
-            logger.info("Could not import %s: %s", modulename, details)
-        # generate the module since it doesn't exist or is out of date
-        logger.info("# Generating %s", modulename)
-        p = tlbparser.TypeLibParser(tlib)
+    def __init__(self, tlib: typeinfo.ITypeLib, pathname: Optional[str]) -> None:
+        self.wrapper_name = codegenerator.name_wrapper_module(tlib)
+        self.friendly_name = codegenerator.name_friendly_module(tlib)
         if pathname is None:
-            pathname = tlbparser.get_tlib_filename(tlib)
-        items = list(p.parse().values())
-        code = self.codegen.generate_wrapper_code(items, filename=pathname)
-        for ext_tlib in self.codegen.externals:  # generates dependency COM-lib modules
+            self.pathname = tlbparser.get_tlib_filename(tlib)
+        else:
+            self.pathname = pathname
+        self.tlib = tlib
+
+    def generate(self) -> types.ModuleType:
+        """Generates wrapper and friendly modules."""
+        known_symbols, known_interfaces = _get_known_namespaces()
+        codegen = codegenerator.CodeGenerator(known_symbols, known_interfaces)
+        codebases: List[Tuple[str, str]] = []
+        logger.info("# Generating %s", self.wrapper_name)
+        items = list(tlbparser.TypeLibParser(self.tlib).parse().values())
+        wrp_code = codegen.generate_wrapper_code(items, filename=self.pathname)
+        codebases.append((self.wrapper_name, wrp_code))
+        if self.friendly_name is not None:
+            logger.info("# Generating %s", self.friendly_name)
+            frd_code = codegen.generate_friendly_code(self.wrapper_name)
+            codebases.append((self.friendly_name, frd_code))
+        for ext_tlib in codegen.externals:  # generates dependency COM-lib modules
             GetModule(ext_tlib)
-        if comtypes.client.gen_dir is None:
-            return _create_module_in_memory(modulename, code)
-        return _create_module_in_file(modulename, code)
+        return [_create_module(name, code) for (name, code) in codebases][-1]
+
 
+_SymbolName = str
+_ModuleName = str
+_ItfName = str
+_ItfIid = str
 
-def _get_known_symbols() -> Dict[str, str]:
-    known_symbols: Dict[str, str] = {}
+
+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.
+    From `comtypes`, only the names in each module's `__known_symbols__` are obtained.
+
+    Note:
+        The interfaces that should be included in `__known_symbols__` should be limited
+        to those that can be said to be bound to the design concept of COM, such as
+        `IUnknown`, and those defined in `objidl` and `oaidl`.
+        `comtypes` does NOT aim to statically define all COM object interfaces in
+        its repository.
+    """
+    known_symbols: Dict[_SymbolName, _ModuleName] = {}
+    known_interfaces: Dict[_ItfName, _ItfIid] = {}
     for mod_name in (
         "comtypes.persist",
         "comtypes.typeinfo",
@@ -259,11 +279,16 @@ def _get_known_symbols() -> Dict[str, str]:
         mod = importlib.import_module(mod_name)
         if hasattr(mod, "__known_symbols__"):
             names: List[str] = mod.__known_symbols__
+            for name in names:
+                tgt = getattr(mod, name)
+                if inspect.isclass(tgt) and issubclass(tgt, comtypes.IUnknown):
+                    assert name not in known_interfaces
+                    known_interfaces[name] = str(tgt._iid_)
         else:
             names = list(mod.__dict__)
         for name in names:
             known_symbols[name] = mod.__name__
-    return known_symbols
+    return known_symbols, known_interfaces
 
 
 ################################################################

{comtypes-1.4.1 → comtypes-1.4.3}/comtypes/hints.pyi

@@ -21,19 +21,46 @@ if sys.version_info >= (3, 8):
     from typing import Protocol
 else:
     from typing_extensions import Protocol
+if sys.version_info >= (3, 9):
+    from typing import Annotated as Annotated
+else:
+    from typing_extensions import Annotated as Annotated
 if sys.version_info >= (3, 10):
-    from typing import Concatenate, ParamSpec
+    from typing import Concatenate, ParamSpec, TypeAlias
+    from typing import TypeGuard as TypeGuard
 else:
-    from typing_extensions import Concatenate, ParamSpec
+    from typing_extensions import Concatenate, ParamSpec, TypeAlias
+    from typing_extensions import TypeGuard as TypeGuard
 if sys.version_info >= (3, 11):
     from typing import Self
 else:
     from typing_extensions import Self
 
+import comtypes
 from comtypes.automation import IDispatch as IDispatch, VARIANT as VARIANT
 from comtypes.server import IClassFactory as IClassFactory
 from comtypes.typeinfo import ITypeInfo as ITypeInfo
 
+Incomplete: TypeAlias = Any
+"""The type symbol is used temporarily until the COM library parsers or
+code generators are enhanced to annotate detailed type hints.
+"""
+
+Hresult: TypeAlias = int
+"""The value returned when calling a method with no `[out]` or `[out, retval]`
+arguments and with `HRESULT` as its return type in its COM method definition.
+"""
+
+_T_coclass = TypeVar("_T_coclass", bound=comtypes.CoClass)
+
+class FirstComItfOf(Generic[_T_coclass]):
+    """When the type assigned to the parameter marked as `'out'` is `CoClass`,
+    the return type of that method at runtime becomes `_com_interface_[0]`
+    due to the metaclass.
+    This is used as `Annotated` metadata for such parameters, taking `CoClass`
+    as an argument.
+    """
+
 class _MethodTypeDesc(Protocol):
     arguments: List[Tuple[Any, str, List[str], Optional[Any]]]
     idlflags: List[str]

{comtypes-1.4.1 → comtypes-1.4.3}/comtypes/test/test_GUID.py

@@ -1,34 +1,55 @@
-import os
 import unittest
 from comtypes import GUID
 
 
 class Test(unittest.TestCase):
-    def test(self):
+    def test_GUID_null(self):
         self.assertEqual(GUID(), GUID())
+        self.assertEqual(
+            str(GUID()),
+            "{00000000-0000-0000-0000-000000000000}",
+        )
+
+    def test_dunder_eq(self):
         self.assertEqual(
             GUID("{00000000-0000-0000-C000-000000000046}"),
             GUID("{00000000-0000-0000-C000-000000000046}"),
         )
 
+    def test_duner_str(self):
         self.assertEqual(
             str(GUID("{0002DF01-0000-0000-C000-000000000046}")),
             "{0002DF01-0000-0000-C000-000000000046}",
         )
+
+    def test_dunder_repr(self):
         self.assertEqual(
             repr(GUID("{0002DF01-0000-0000-C000-000000000046}")),
             'GUID("{0002DF01-0000-0000-C000-000000000046}")',
         )
 
+    def test_invalid_constructor_arg(self):
         self.assertRaises(WindowsError, GUID, "abc")
+
+    def test_from_progid(self):
+        self.assertEqual(
+            GUID.from_progid("Scripting.FileSystemObject"),
+            GUID("{0D43FE01-F093-11CF-8940-00A0C9054228}"),
+        )
         self.assertRaises(WindowsError, GUID.from_progid, "abc")
 
+    def test_as_progid(self):
+        self.assertEqual(
+            GUID("{0D43FE01-F093-11CF-8940-00A0C9054228}").as_progid(),
+            "Scripting.FileSystemObject",
+        )
         self.assertRaises(
             WindowsError,
             lambda guid: guid.as_progid(),
             GUID("{00000000-0000-0000-C000-000000000046}"),
         )
 
+    def test_create_new(self):
         self.assertNotEqual(GUID.create_new(), GUID.create_new())
 
 

{comtypes-1.4.1 → comtypes-1.4.3}/comtypes/test/test_client.py

@@ -59,12 +59,17 @@ class Test_GetModule(ut.TestCase):
         mod = comtypes.client.GetModule(typeinfo.LoadTypeLibEx("scrrun.dll"))
         self.assertIs(mod, Scripting)
 
-    def test_imports_IEnumVARIANT_from_other_generated_modules(self):
+    def test_mscorlib(self):
         # NOTE: `codegenerator` generates code that contains unused imports,
         # but removing them are attracting wierd bugs in library-wrappers
         # which depend on externals.
-        # NOTE: `mscorlib`, which imports `IEnumVARIANT` from `stdole`.
-        comtypes.client.GetModule(("{BED7F4EA-1A96-11D2-8F08-00A0C9A6186D}",))
+        # `mscorlib` imports `stdole` wrapper module and refers`IEnumVARIANT` from it.
+        mod = comtypes.client.GetModule(("{BED7F4EA-1A96-11D2-8F08-00A0C9A6186D}",))
+        # NOTE: `ModuleGenerator` treats the `ctypes._Pointer` base class for pointers
+        # as one of the known symbols, but `mscorlib` has the `_Pointer` com interface.
+        # Even though they have the same name, `codegenerator` generates code to define
+        # the `_Pointer` interface, rather than importing `_Pointer` from `ctypes`.
+        self.assertTrue(issubclass(mod._Pointer, comtypes.IUnknown))
 
     def test_no_replacing_Patch_namespace(self):
         # NOTE: An object named `Patch` is defined in some dll.
@@ -82,7 +87,12 @@ class Test_GetModule(ut.TestCase):
         # the definition of an enumeration, the generation of the module will fail.
         # See also https://github.com/enthought/comtypes/issues/524
         with contextlib.redirect_stdout(None):  # supress warnings
-            comtypes.client.GetModule("mshtml.tlb")
+            mshtml = comtypes.client.GetModule("mshtml.tlb")
+        # When the member of an enumeration and a CoClass have the same name,
+        # the defined later one is assigned to the name in the module.
+        # By asserting whether the CoClass is assigned to that name, it ensures
+        # that the member of the enumeration is defined earlier.
+        self.assertTrue(issubclass(mshtml.htmlInputImage, comtypes.CoClass))
 
     def test_abstracted_wrapper_module_in_friendly_module(self):
         mod = comtypes.client.GetModule("scrrun.dll")