comtypes 1.1.14__zip → 1.2.1__zip

comtypes-1.2.1/comtypes/client/_generate.py

@@ -0,0 +1,274 @@
+from __future__ import print_function
+import ctypes
+import importlib
+import logging
+import os
+import sys
+import types
+if sys.version_info >= (3, 0):
+    base_text_type = str
+    import winreg
+else:
+    base_text_type = basestring
+    import _winreg as winreg
+
+from comtypes import GUID, TYPE_CHECKING, typeinfo
+import comtypes.client
+from comtypes.tools import codegenerator, tlbparser
+
+if TYPE_CHECKING:
+    from typing import Any, Tuple, List, Optional, Dict, Union as _UnionT
+
+
+logger = logging.getLogger(__name__)
+
+PATH = os.environ["PATH"].split(os.pathsep)
+
+
+def _my_import(fullname):
+    # type: (str) -> types.ModuleType
+    """helper function to import dotted modules"""
+    import comtypes.gen as g
+    if comtypes.client.gen_dir and comtypes.client.gen_dir not in g.__path__:
+        g.__path__.append(comtypes.client.gen_dir)  # type: ignore
+    return importlib.import_module(fullname)
+
+
+def _resolve_filename(tlib_string, dirpath):
+    # type: (str, str) -> Tuple[str, bool]
+    """Tries to make sense of a type library specified as a string.
+
+    Args:
+        tlib_string: type library designator
+        dirpath: a directory to relativize the location
+
+    Returns:
+        (abspath, True) or (relpath, False):
+            where relpath is an unresolved path.
+    """
+    assert isinstance(tlib_string, base_text_type)
+    # pathname of type library
+    if os.path.isabs(tlib_string):
+        # a specific location
+        return tlib_string, True
+    elif dirpath:
+        abspath = os.path.normpath(os.path.join(dirpath, tlib_string))
+        if os.path.exists(abspath):
+            return abspath, True
+    # try with respect to cwd (if _getmodule executed from command line)
+    abspath = os.path.abspath(tlib_string)
+    if os.path.exists(abspath):
+        return abspath, True
+    # Otherwise it may still be that the file is on Windows search
+    # path for typelibs, and we leave the pathname alone.
+    return tlib_string, False
+
+
+def GetModule(tlib):
+    # type: (_UnionT[Any, typeinfo.ITypeLib]) -> types.ModuleType
+    """Create a module wrapping a COM typelibrary on demand.
+
+    'tlib' must be ...
+    - an `ITypeLib` COM pointer instance
+    - an absolute pathname of a type library
+    - a relative pathname of a type library
+      - interpreted as relative to the callers `__file__`, if this exists
+    - a COM CLSID `GUID`
+    - a `tuple`/`list` specifying the typelib
+      - `List[_UnionT[str, int]]`
+      - `(libid: str[, wMajorVerNum: int, wMinorVerNum: int[, lcid: int]])`
+    - an object with `_reg_libid_: str` and `_reg_version_: Iterable[int]`
+
+    This function determines the module name from the typelib
+    attributes, then tries to import it.  If that fails because the
+    module doesn't exist, the module is generated into the
+    `comtypes.gen` package.
+
+    It is possible to delete the whole `comtypes/gen` directory to
+    remove all generated modules, the directory and the `__init__.py`
+    file in it will be recreated when needed.
+
+    If `comtypes.gen.__path__` is not a directory (in a frozen
+    executable it lives in a zip archive), generated modules are only
+    created in memory without writing them to the file system.
+
+    Example:
+        GetModule("UIAutomationCore.dll")
+
+    would create modules named
+
+        `comtypes.gen._944DE083_8FB8_45CF_BCB7_C477ACB2F897_L_M_m`
+          - typelib wrapper module
+          - where L, M, m are numbers of Lcid, Major-ver, minor-ver
+        `comtypes.gen.UIAutomationClient`
+          - friendly named module
+
+    containing the Python wrapper code for the type library used by
+    UIAutomation.  The former module contains all the code, the
+    latter is a short stub loading the former.
+    """
+    if isinstance(tlib, base_text_type):
+        tlib_string = tlib
+        # if a relative pathname is used, we try to interpret it relative to
+        # the directory of the calling module (if not from command line)
+        frame = sys._getframe(1)
+        _file_ = frame.f_globals.get("__file__", None)  # type: str
+        pathname, is_abs = _resolve_filename(tlib_string, _file_ and os.path.dirname(_file_))
+        logger.debug("GetModule(%s), resolved: %s", pathname, is_abs)
+        tlib = _load_tlib(pathname)  # don't register
+        if not is_abs:
+            # try to get path after loading, but this only works if already registered
+            pathname = tlbparser.get_tlib_filename(tlib)
+            if pathname is None:
+                logger.info("GetModule(%s): could not resolve to a filename", tlib)
+                pathname = tlib_string
+        # if above path torture resulted in an absolute path, then the file exists (at this point)!
+        assert not(os.path.isabs(pathname)) or os.path.exists(pathname)
+    else:
+        pathname = None
+        tlib = _load_tlib(tlib)
+    logger.debug("GetModule(%s)", tlib.GetLibAttr())
+    # create and import the real typelib wrapper module
+    mod = _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
+    if sys.version_info < (3, 0):
+        modulename = modulename.encode("mbcs")
+    # create and import the friendly-named module
+    return _create_friendly_module(tlib, modulename)
+
+
+def _load_tlib(obj):
+    # type: (Any) -> typeinfo.ITypeLib
+    """Load a pointer of ITypeLib on demand."""
+    # obj is a filepath or a ProgID
+    if isinstance(obj, base_text_type):
+        # in any case, attempt to load and if tlib_string is not valid, then raise
+        # as "OSError: [WinError -2147312566] Error loading type library/DLL"
+        return typeinfo.LoadTypeLibEx(obj)
+    # obj is a tlib GUID contain a clsid
+    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:
+            libid = winreg.EnumValue(key, 0)[1]
+        with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"CLSID\%s\Version" % clsid) 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:
+                ver = [int(v, base=16) for v in winreg.EnumKey(key, 0).split(".")]
+        return typeinfo.LoadRegTypeLib(GUID(libid), *ver)
+    # obj is a COMObject implementation
+    elif hasattr(obj, "_reg_libid_"):
+        return typeinfo.LoadRegTypeLib(GUID(obj._reg_libid_), *obj._reg_version_)
+    # 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)
+
+
+def _create_module_in_file(modulename, code):
+    # type: (str, str) -> types.ModuleType
+    """create module in file system, and import 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:
+        print(code, file=ofi)
+    # clear the import cache to make sure Python sees newly created modules
+    if hasattr(importlib, "invalidate_caches"):
+        importlib.invalidate_caches()
+    return _my_import(modulename)
+
+
+def _create_module_in_memory(modulename, code):
+    # type: (str, 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
+
+
+def _create_friendly_module(tlib, modulename):
+    # type: (typeinfo.ITypeLib, 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).split(".")[-1]
+    code = "from comtypes.gen import %s\n" % modname
+    code += "globals().update(%s.__dict__)\n" % modname
+    code += "__name__ = '%s'" % modulename
+    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(tlib, pathname):
+    # type: (typeinfo.ITypeLib, 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)
+    if pathname is None:
+        pathname = tlbparser.get_tlib_filename(tlib)
+    items = list(p.parse().values())
+    codegen = codegenerator.CodeGenerator(_get_known_symbols())
+    code = codegen.generate_code(items, filename=pathname)
+    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)
+
+
+def _get_known_symbols():
+    # type: () -> Dict[str, str]
+    known_symbols = {}  # type: Dict[str, str]
+    for mod_name in (
+        "comtypes.persist",
+        "comtypes.typeinfo",
+        "comtypes.automation",
+        "comtypes",
+        "ctypes.wintypes",
+        "ctypes"
+    ):
+        mod = importlib.import_module(mod_name)
+        if hasattr(mod, "__known_symbols__"):
+            names = mod.__known_symbols__  # type: List[str]
+        else:
+            names = list(mod.__dict__)
+        for name in names:
+            known_symbols[name] = mod.__name__
+    return known_symbols
+
+################################################################
+
+
+if __name__ == "__main__":
+    # When started as script, generate typelib wrapper from .tlb file.
+    GetModule(sys.argv[1])

comtypes-1.2.1/comtypes/hints.pyi

@@ -0,0 +1,26 @@
+from typing import (
+    Any, Callable, Generic, NoReturn, Optional, overload, SupportsIndex,
+    Type, TypeVar, Union as _UnionT,
+)
+
+# symbols those what might occur recursive imports in runtime.
+from comtypes.automation import IDispatch as IDispatch, VARIANT as VARIANT
+from comtypes.server import IClassFactory as IClassFactory
+from comtypes.typeinfo import ITypeInfo as ITypeInfo
+
+
+def AnnoField() -> Any:
+    """**THIS IS `TYPE_CHECKING` ONLY SYMBOL.
+
+    This is workaround for class field type annotations for old
+    python versions.
+
+    Examples:
+        # instead of class field annotation, like below
+
+        class Foo:
+            # spam: int  # <- not available in old versions.
+            if TYPE_CHECKING:
+                spam = AnnoField()  # type: int  # <- available in old versions.
+    """
+    ...

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/persist.py

@@ -210,3 +210,17 @@ class DictPropertyBag(COMObject):
         val = var[0].value
         self.values[name] = val
         return S_OK
+
+
+__known_symbols__ = [
+    'CLIPFORMAT', 'DictPropertyBag', 'IErrorLog', 'IPersistFile',
+    'IPersistPropertyBag', 'IPersistPropertyBag2', 'IPropertyBag',
+    'IPropertyBag2', 'tagPROPBAG2', 'PROPBAG2_TYPE_DATA',
+    'PROPBAG2_TYPE_MONIKER', 'PROPBAG2_TYPE_OBJECT', 'PROPBAG2_TYPE_STORAGE',
+    'PROPBAG2_TYPE_STREAM', 'PROPBAG2_TYPE_UNDEFINED', 'PROPBAG2_TYPE_URL',
+    'STGM_CONVERT', 'STGM_CREATE', 'STGM_DELETEONRELEASE', 'STGM_DIRECT',
+    'STGM_DIRECT_SWMR', 'STGM_FAILIFTHERE', 'STGM_NOSCRATCH',
+    'STGM_NOSNAPSHOT', 'STGM_PRIORITY', 'STGM_READ', 'STGM_READWRITE',
+    'STGM_SHARE_DENY_NONE', 'STGM_SHARE_DENY_READ', 'STGM_SHARE_DENY_WRITE',
+    'STGM_SHARE_EXCLUSIVE', 'STGM_SIMPLE', 'STGM_TRANSACTED', 'STGM_WRITE',
+]

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/safearray.py

@@ -1,11 +1,11 @@
 import threading
 import array
+import comtypes
 from ctypes import (POINTER, Structure, byref, cast, c_long, memmove, pointer,
                     sizeof)
-from comtypes import _safearray, IUnknown, com_interface_registry, npsupport
+from comtypes import _safearray, IUnknown, com_interface_registry
 from comtypes.patcher import Patch
 
-numpy = npsupport.numpy
 _safearray_type_cache = {}
 
 
@@ -27,6 +27,7 @@ class _SafeArrayAsNdArrayContextManager(object):
     thread_local = threading.local()
 
     def __enter__(self):
+        comtypes.npsupport.enable()
         try:
             self.thread_local.count += 1
         except AttributeError:
@@ -113,7 +114,7 @@ def _make_safearray_type(itemtype):
             one-dimensional arrays.  To create multidimensional arrys,
             numpy arrays must be passed.
             """
-            if npsupport.isndarray(value):
+            if comtypes.npsupport.isndarray(value):
                 return cls.create_from_ndarray(value, extra)
 
             # For VT_UNKNOWN or VT_DISPATCH, extra must be a pointer to
@@ -156,18 +157,18 @@ def _make_safearray_type(itemtype):
             from comtypes.automation import VARIANT
             # If processing VARIANT, makes sure the array type is correct.
             if cls._itemtype_ is VARIANT:
-                if value.dtype != npsupport.VARIANT_dtype:
+                if value.dtype != comtypes.npsupport.VARIANT_dtype:
                     value = _ndarray_to_variant_array(value)
             else:
                 ai = value.__array_interface__
                 if ai["version"] != 3:
                     raise TypeError("only __array_interface__ version 3 supported")
-                if cls._itemtype_ != npsupport.typecodes[ai["typestr"]]:
+                if cls._itemtype_ != comtypes.npsupport.typecodes[ai["typestr"]]:
                     raise TypeError("Wrong array item type")
 
             # SAFEARRAYs have Fortran order; convert the numpy array if needed
             if not value.flags.f_contiguous:
-                value = numpy.array(value, order="F")
+                value = comtypes.npsupport.numpy.array(value, order="F")
 
             # For VT_UNKNOWN or VT_DISPATCH, extra must be a pointer to
             # the GUID of the interface.
@@ -240,15 +241,13 @@ def _make_safearray_type(itemtype):
 
             if dim == 0:
                 if safearray_as_ndarray:
-                    import numpy
-                    return numpy.array()
+                    return comtypes.npsupport.numpy.array()
                 return tuple()
             elif dim == 1:
                 num_elements = self._get_size(1)
                 result = self._get_elements_raw(num_elements)
                 if safearray_as_ndarray:
-                    import numpy
-                    return numpy.asarray(result)
+                    return comtypes.npsupport.numpy.asarray(result)
                 return tuple(result)
             elif dim == 2:
                 # get the number of elements in each dimension
@@ -258,8 +257,7 @@ def _make_safearray_type(itemtype):
                 # this must be reshaped and transposed because it is
                 # flat, and in VB order
                 if safearray_as_ndarray:
-                    import numpy
-                    return numpy.asarray(result).reshape((cols, rows)).T
+                    return comtypes.npsupport.numpy.asarray(result).reshape((cols, rows)).T
                 result = [tuple(result[r::rows]) for r in range(rows)]
                 return tuple(result)
             else:
@@ -270,8 +268,7 @@ def _make_safearray_type(itemtype):
                                for d in range(1, dim+1)]
                 row = self._get_row(0, indexes, lowerbounds, upperbounds)
                 if safearray_as_ndarray:
-                    import numpy
-                    return numpy.asarray(row)
+                    return comtypes.npsupport.numpy.asarray(row)
                 return row
 
         def _get_elements_raw(self, num_elements):
@@ -315,8 +312,8 @@ def _make_safearray_type(itemtype):
                         # XXX Only try to convert types known to
                         #     numpy.ctypeslib.
                         if (safearray_as_ndarray and self._itemtype_ in
-                                list(npsupport.typecodes.keys())):
-                            arr = numpy.ctypeslib.as_array(ptr,
+                                list(comtypes.npsupport.typecodes.keys())):
+                            arr = comtypes.npsupport.numpy.ctypeslib.as_array(ptr,
                                                            (num_elements,))
                             return arr.copy()
                         return ptr[:num_elements]
@@ -372,17 +369,20 @@ def _make_safearray_type(itemtype):
 def _ndarray_to_variant_array(value):
     """ Convert an ndarray to VARIANT_dtype array """
     # Check that variant arrays are supported
-    if npsupport.VARIANT_dtype is None:
+    if comtypes.npsupport.interop.VARIANT_dtype is None:
         msg = "VARIANT ndarrays require NumPy 1.7 or newer."
         raise RuntimeError(msg)
+    numpy = comtypes.npsupport.interop.numpy
 
     # special cases
-    if numpy.issubdtype(value.dtype, npsupport.datetime64):
+    if numpy.issubdtype(value.dtype, comtypes.npsupport.interop.datetime64):
         return _datetime64_ndarray_to_variant_array(value)
 
     from comtypes.automation import VARIANT
     # Empty array
-    varr = numpy.zeros(value.shape, npsupport.VARIANT_dtype, order='F')
+    varr = numpy.zeros(
+        value.shape, comtypes.npsupport.interop.VARIANT_dtype, order='F'
+    )
     # Convert each value to a variant and put it in the array.
     varr.flat = [VARIANT(v) for v in value.flat]
     return varr
@@ -394,11 +394,12 @@ def _datetime64_ndarray_to_variant_array(value):
     # since midnight 30 December 1899. Hours and minutes are represented as
     # fractional days.
     from comtypes.automation import VT_DATE
+    numpy = comtypes.npsupport.interop.numpy
     value = numpy.array(value, "datetime64[ns]")
-    value = value - npsupport.com_null_date64
+    value = value - comtypes.npsupport.interop.com_null_date64
     # Convert to days
     value = value / numpy.timedelta64(1, 'D')
-    varr = numpy.zeros(value.shape, npsupport.VARIANT_dtype, order='F')
+    varr = numpy.zeros(value.shape, comtypes.npsupport.interop.VARIANT_dtype, order='F')
     varr['vt'] = VT_DATE
     varr['_']['VT_R8'].flat = value.flat
     return varr

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/test/__init__.py

@@ -10,13 +10,6 @@ import unittest
 
 use_resources = ["*"]
 
-def get_numpy():
-    '''Get numpy if it is available.'''
-    try:
-        import numpy
-        return numpy
-    except ImportError:
-        return None
 
 def register_server(source_dir):
     """ Register testing server appropriate for the python architecture.

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/test/test_client.py

@@ -69,6 +69,11 @@ class Test_GetModule(ut.TestCase):
         mod = comtypes.client.GetModule(clsid)
         self.assertEqual(mod.MediaPlayer._reg_clsid_, clsid)
 
+    def test_ptr_itypelib(self):
+        from comtypes import typeinfo
+        mod = comtypes.client.GetModule(typeinfo.LoadTypeLibEx("scrrun.dll"))
+        self.assertIs(mod, Scripting)
+
     def test_imports_IEnumVARIANT_from_other_generated_modules(self):
         # NOTE: `codegenerator` generates code that contains unused imports,
         # but removing them are attracting wierd bugs in library-wrappers
@@ -84,6 +89,36 @@ class Test_GetModule(ut.TestCase):
         # NOTE: `WindowsInstaller`, which has `Patch` definition in dll.
         comtypes.client.GetModule("msi.dll")
 
+    def test_raises_typerror_if_takes_unsupported(self):
+        with self.assertRaises(TypeError):
+            comtypes.client.GetModule(object())
+
+
+class Test_KnownSymbols(ut.TestCase):
+    # It is guaranteed that each element of `__known_symbols__` is in
+    # each module's namespace.
+    # If this test fails, `ImportError` or `AttributeError` may be raised
+    # when generating a `comtypes.gen._xxx...` in runtime.
+    def _doit(self, mod):
+        for s in mod.__known_symbols__:
+            self.assertTrue(hasattr(mod, s))
+
+    def test_symbols_in_comtypes(self):
+        import comtypes
+        self._doit(comtypes)
+
+    def test_symbols_in_comtypes_automation(self):
+        import comtypes.automation
+        self._doit(comtypes.automation)
+
+    def test_symbols_in_comtypes_typeinfo(self):
+        import comtypes.typeinfo
+        self._doit(comtypes.typeinfo)
+
+    def test_symbols_in_comtypes_persist(self):
+        import comtypes.persist
+        self._doit(comtypes.persist)
+
 
 class Test_CreateObject(ut.TestCase):
     def test_progid(self):

{comtypes-1.1.14 → comtypes-1.2.1}/comtypes/test/test_dict.py

@@ -7,10 +7,6 @@ from comtypes.client import CreateObject
 from comtypes.client.lazybind import Dispatch
 
 
-def setUpModule():
-    raise unittest.SkipTest("Depends on `comtypes.safearray` which depends on numpy which isn't "
-                            "listed in project dependencies.")
-
 class Test(unittest.TestCase):
     def test_dict(self):
         d = CreateObject("Scripting.Dictionary", dynamic=True)