comtypes 1.4.10__zip → 1.4.11__zip

comtypes-1.4.11/comtypes/test/test_errorinfo.py

@@ -0,0 +1,115 @@
+import unittest as ut
+
+from comtypes import errorinfo, shelllink
+from comtypes import hresult as hres
+
+
+class Test_GetErrorInfo(ut.TestCase):
+    def test_error_has_been_set(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        errmsg = "sample unexpected error message for tests"
+        errcode = hres.E_UNEXPECTED
+        helpcontext = 123
+        hr = errorinfo.ReportError(
+            errmsg,
+            shelllink.IShellLinkW._iid_,
+            str(shelllink.ShellLink._reg_clsid_),
+            helpfile="help.chm",
+            helpcontext=helpcontext,
+            hresult=errcode,
+        )
+        self.assertEqual(errcode, hr)
+        pei = errorinfo.GetErrorInfo()
+        self.assertIsNotNone(pei)
+        assert pei is not None  # for static type guard
+        self.assertEqual(shelllink.IShellLinkW._iid_, pei.GetGUID())
+        self.assertEqual("lnkfile", pei.GetSource())
+        self.assertEqual(errmsg, pei.GetDescription())
+        self.assertEqual("help.chm", pei.GetHelpFile())
+        self.assertEqual(helpcontext, pei.GetHelpContext())
+        # Calling `GetErrorInfo` clears the error state for the thread.
+        # Therefore, `None` is returned in the second call.
+        self.assertIsNone(errorinfo.GetErrorInfo())
+
+    def test_without_optional_args(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        errmsg = "sample unexpected error message for tests"
+        hr = errorinfo.ReportError(errmsg, shelllink.IShellLinkW._iid_)
+        self.assertEqual(hres.DISP_E_EXCEPTION, hr)
+        pei = errorinfo.GetErrorInfo()
+        self.assertIsNotNone(pei)
+        assert pei is not None  # for static type guard
+        self.assertEqual(shelllink.IShellLinkW._iid_, pei.GetGUID())
+        self.assertIsNone(pei.GetSource())
+        self.assertEqual(errmsg, pei.GetDescription())
+        self.assertIsNone(pei.GetHelpFile())
+        self.assertEqual(0, pei.GetHelpContext())
+
+    def test_error_has_not_been_set(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        pei = errorinfo.GetErrorInfo()
+        self.assertIsNone(pei)
+
+
+def raise_runtime_error():
+    _raise_runtime_error()
+
+
+def _raise_runtime_error():
+    raise RuntimeError("for testing")
+
+
+class Test_ReportException(ut.TestCase):
+    def test_without_stacklevel(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        iid = shelllink.IShellLinkW._iid_
+        try:
+            raise_runtime_error()
+        except RuntimeError:
+            hr = errorinfo.ReportException(hres.E_UNEXPECTED, iid)
+        self.assertEqual(hres.E_UNEXPECTED, hr)
+        pei = errorinfo.GetErrorInfo()
+        self.assertIsNotNone(pei)
+        assert pei is not None  # for static type guard
+        self.assertEqual(shelllink.IShellLinkW._iid_, pei.GetGUID())
+        self.assertIsNone(pei.GetSource())
+        self.assertEqual("<class 'RuntimeError'>: for testing", pei.GetDescription())
+        self.assertIsNone(pei.GetHelpFile())
+        self.assertEqual(0, pei.GetHelpContext())
+        self.assertIsNone(errorinfo.GetErrorInfo())
+
+    def test_with_stacklevel(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        stem = "<class 'RuntimeError'>: for testing"
+        iid = shelllink.IShellLinkW._iid_
+        for slv, text in [
+            # XXX: If the codebase changes, the line where functions or
+            # methods are defined will change, meaning this test is brittle.
+            (0, f"{stem} ({__name__}, line 96)"),
+            (1, f"{stem} ({__name__}, line 55)"),
+            (2, f"{stem} ({__name__}, line 59)"),
+        ]:
+            with self.subTest(text=text):
+                try:
+                    raise_runtime_error()
+                except RuntimeError:
+                    errorinfo.ReportException(hres.E_UNEXPECTED, iid, stacklevel=slv)
+                pei = errorinfo.GetErrorInfo()
+                assert pei is not None  # for static type guard
+                self.assertEqual(text, pei.GetDescription())
+                self.assertIsNone(errorinfo.GetErrorInfo())
+
+    def test_with_over_stacklevel(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        iid = shelllink.IShellLinkW._iid_
+        try:
+            raise_runtime_error()
+        except RuntimeError:
+            with self.assertRaises(ValueError):
+                errorinfo.ReportException(hres.E_UNEXPECTED, iid, stacklevel=4)
+
+    def test_with_no_error_and_zero_stacklevel(self):
+        self.assertIsNone(errorinfo.GetErrorInfo())
+        iid = shelllink.IShellLinkW._iid_
+        with self.assertRaises(ValueError):
+            errorinfo.ReportException(hres.E_UNEXPECTED, iid, stacklevel=0)

comtypes-1.4.11/comtypes/test/test_hresult.py

@@ -0,0 +1,48 @@
+import unittest as ut
+
+import comtypes.hresult
+
+
+class Test_MAKE_HRESULT(ut.TestCase):
+    def test(self):
+        for sev, fac, code, hr in [
+            (0x0000, 0x0000, 0x0000, 0),
+            (0x0001, 0x0000, 0x0000, -2147483648),
+            (0x0000, 0x0001, 0x0000, 65536),
+            (0x0000, 0x0000, 0x0001, 1),
+            (0x0001, 0xFFFF, 0xFFFF, -1),
+            (0x0000, 0xFFFF, 0xFFFF, -1),
+            (0x0001, 0x0000, 0x0001, -2147483647),
+            (0x0001, 0x0001, 0x0001, -2147418111),
+            (0x0000, 0x0001, 0xFFFF, 131071),
+            (0x0001, 0xFFFF, 0x0000, -65536),
+            (0x0001, 0x0000, 0xFFFF, -2147418113),
+        ]:
+            with self.subTest(sev=sev, fac=fac, code=code, hr=hr):
+                self.assertEqual(comtypes.hresult.MAKE_HRESULT(sev, fac, code), hr)
+
+
+ERROR_OUTOFMEMORY = 14  # 0xE
+ERROR_INVALID_PARAMETER = 87  # 0x57
+RPC_S_SERVER_UNAVAILABLE = 1722  # 0x6BA
+
+
+class Test_HRESULT_FROM_WIN32(ut.TestCase):
+    def test(self):
+        for w32, hr in [
+            (ERROR_OUTOFMEMORY, comtypes.hresult.E_OUTOFMEMORY),
+            (ERROR_INVALID_PARAMETER, comtypes.hresult.E_INVALIDARG),
+            (RPC_S_SERVER_UNAVAILABLE, comtypes.hresult.RPC_S_SERVER_UNAVAILABLE),
+            (-1, -1),
+            (0, -2147024896),
+            (1, -2147024895),
+            (0xFFFF - 3, -2146959364),
+            (0xFFFF - 2, -2146959363),
+            (0xFFFF - 1, -2146959362),
+            (0xFFFF + 0, -2146959361),
+            (0xFFFF + 1, -2147024896),
+            (0xFFFF + 2, -2147024895),
+            (0xFFFF + 3, -2147024894),
+        ]:
+            with self.subTest(w32=w32, hr=hr):
+                self.assertEqual(comtypes.hresult.HRESULT_FROM_WIN32(w32), hr)

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_inout_args.py

@@ -8,7 +8,14 @@ from comtypes import IUnknown
 from comtypes._memberspec import _fix_inout_args
 
 if TYPE_CHECKING:
-    from comtypes._memberspec import _ArgSpecElmType
+    from comtypes import hints  # type: ignore
+
+    _ArgSpecType = Tuple[
+        hints.ArgSpecElmType,
+        hints.ArgSpecElmType,
+        hints.ArgSpecElmType,
+        hints.ArgSpecElmType,
+    ]
 
 WSTRING = c_wchar_p
 
@@ -259,7 +266,7 @@ class Test_ArgsKwargsCombinations(ut.TestCase):
 
 
 class PermutedArgspecTestingParams(NamedTuple):
-    argspec: "Tuple[_ArgSpecElmType, _ArgSpecElmType, _ArgSpecElmType, _ArgSpecElmType]"
+    argspec: "_ArgSpecType"
     args: Tuple[Any, Any, Any]
     orig_ret_val: Tuple[Any, Any, Any]
     fixed_ret_val: List[Any]

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_safearray.py

@@ -129,7 +129,8 @@ class SafeArrayTestCase(unittest.TestCase):
         self.assertEqual(SafeArrayGetVartype(sa), VT_I4)
 
         # TypeError: len() of unsized object
-        self.assertRaises(TypeError, lambda: t.from_param(object()))
+        with self.assertRaises(TypeError):
+            t.from_param(object())
 
     def test_VT_VARIANT(self):
         t = _midlSAFEARRAY(VARIANT)

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_server_register.py

@@ -3,6 +3,7 @@ import os
 import sys
 import unittest as ut
 import winreg
+from ctypes.wintypes import MAX_PATH
 from unittest import mock
 
 import comtypes
@@ -236,7 +237,7 @@ class Test_get_serverdll(ut.TestCase):
         self.assertEqual(dll_path, _get_serverdll(handle))
         (((hmodule, maxsize), _),) = GetModuleFileName.call_args_list
         self.assertEqual(handle, hmodule)
-        self.assertEqual(260, maxsize)
+        self.assertEqual(MAX_PATH, maxsize)
 
 
 class Test_InterpRegistryEntries(ut.TestCase):

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_typeinfo.py

@@ -1,6 +1,7 @@
 import ctypes
 import sys
 import unittest
+from ctypes.wintypes import MAX_PATH
 
 from comtypes import GUID, COMError
 from comtypes.typeinfo import (
@@ -96,14 +97,30 @@ class Test(unittest.TestCase):
 
 class Test_GetModuleFileName(unittest.TestCase):
     def test_null_handler(self):
-        self.assertEqual(GetModuleFileName(None, 260), sys.executable)
+        self.assertEqual(GetModuleFileName(None, MAX_PATH), sys.executable)
 
     def test_loaded_module_handle(self):
         import _ctypes
 
         dll_path = _ctypes.__file__
         hmodule = ctypes.WinDLL(dll_path)._handle
-        self.assertEqual(GetModuleFileName(hmodule, 260), dll_path)
+        self.assertEqual(GetModuleFileName(hmodule, MAX_PATH), dll_path)
+
+    def test_invalid_handle(self):
+        with self.assertRaises(OSError) as ce:
+            GetModuleFileName(1, MAX_PATH)
+        ERROR_MOD_NOT_FOUND = 126
+        self.assertEqual(ce.exception.winerror, ERROR_MOD_NOT_FOUND)
+
+    def test_invalid_nsize(self):
+        import _ctypes
+
+        dll_path = _ctypes.__file__
+        hmodule = ctypes.WinDLL(dll_path)._handle
+        with self.assertRaises(OSError) as ce:
+            GetModuleFileName(hmodule, 0)
+        ERROR_INSUFFICIENT_BUFFER = 122
+        self.assertEqual(ce.exception.winerror, ERROR_INSUFFICIENT_BUFFER)
 
 
 if __name__ == "__main__":

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_variant.py

@@ -66,7 +66,8 @@ class VariantTestCase(unittest.TestCase):
 
         missing = VARIANT.missing
         self.assertEqual(missing.vt, VT_ERROR)
-        self.assertRaises(NotImplementedError, lambda: missing.value)
+        with self.assertRaises(NotImplementedError):
+            missing.value
 
     def test_com_refcounts(self):
         # typelib for oleaut32

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/test/test_w_getopt.py

@@ -20,10 +20,10 @@ class TestCase(unittest.TestCase):
 
     def test_3(self):
         # Invalid option
-        self.assertRaises(
-            GetoptError, w_getopt, "/TLIB hello.tlb hello.idl".split(), ["tlb:"]
-        )
+        with self.assertRaises(GetoptError):
+            w_getopt("/TLIB hello.tlb hello.idl".split(), ["tlb:"])
 
     def test_4(self):
         # Missing argument
-        self.assertRaises(GetoptError, w_getopt, "/TLB".split(), ["tlb:"])
+        with self.assertRaises(GetoptError):
+            w_getopt("/TLB".split(), ["tlb:"])

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/tools/tlbparser.py

@@ -1,10 +1,11 @@
 import os
 import sys
+from _ctypes import COMError
 from ctypes import alignment, c_void_p, sizeof, windll
+from ctypes.wintypes import MAX_PATH
 from typing import Any, Dict, List, Optional, Tuple
 
-from comtypes import BSTR, COMError, automation, typeinfo
-from comtypes.client._code_cache import _get_module_filename
+from comtypes import automation, typeinfo
 from comtypes.tools import typedesc
 
 # Is the process 64-bit?
@@ -750,7 +751,7 @@ def get_tlib_filename(tlib: typeinfo.ITypeLib) -> Optional[str]:
         # workaround Windows 7 bug in QueryPathOfRegTypeLib returning relative path
         try:
             dll = windll.LoadLibrary(full_filename)
-            full_filename = _get_module_filename(dll._handle)
+            full_filename = typeinfo.GetModuleFileName(dll._handle, MAX_PATH)
             del dll
         except OSError:
             return None
@@ -759,9 +760,9 @@ def get_tlib_filename(tlib: typeinfo.ITypeLib) -> Optional[str]:
 
 def _py2exe_hint():
     # If the tlbparser is frozen, we need to include these
-    import comtypes.automation
-    import comtypes.persist
-    import comtypes.typeinfo
+    import comtypes.automation  # noqa
+    import comtypes.persist  # noqa
+    import comtypes.typeinfo  # noqa
 
 
 # -eof-

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes/typeinfo.py

@@ -45,6 +45,14 @@ from typing import (
 from typing import Union as _UnionT
 
 from comtypes import BSTR, COMMETHOD, GUID, IID, STDMETHOD, IUnknown, _CData
+from comtypes._memberspec import PARAMFLAG_FHASCUSTDATA as PARAMFLAG_FHASCUSTDATA
+from comtypes._memberspec import PARAMFLAG_FHASDEFAULT as PARAMFLAG_FHASDEFAULT
+from comtypes._memberspec import PARAMFLAG_FIN as PARAMFLAG_FIN
+from comtypes._memberspec import PARAMFLAG_FLCID as PARAMFLAG_FLCID
+from comtypes._memberspec import PARAMFLAG_FOPT as PARAMFLAG_FOPT
+from comtypes._memberspec import PARAMFLAG_FOUT as PARAMFLAG_FOUT
+from comtypes._memberspec import PARAMFLAG_FRETVAL as PARAMFLAG_FRETVAL
+from comtypes._memberspec import PARAMFLAG_NONE as PARAMFLAG_NONE
 from comtypes.automation import (
     DISPID,
     DISPPARAMS,
@@ -205,15 +213,6 @@ VARFLAG_FREPLACEABLE = 2048
 VARFLAG_FIMMEDIATEBIND = 4096
 VARFLAGS = tagVARFLAGS
 
-PARAMFLAG_NONE = 0
-PARAMFLAG_FIN = 1
-PARAMFLAG_FOUT = 2
-PARAMFLAG_FLCID = 4
-PARAMFLAG_FRETVAL = 8
-PARAMFLAG_FOPT = 16
-PARAMFLAG_FHASDEFAULT = 32
-PARAMFLAG_FHASCUSTDATA = 64
-
 ################################################################
 # a helper
 
@@ -770,6 +769,8 @@ def GetModuleFileName(handle: Optional[int], maxsize: int) -> str:
     """
     buf = create_unicode_buffer(maxsize)
     length = _GetModuleFileNameW(handle, buf, maxsize)
+    if not length:
+        raise ctypes.WinError()
     return buf.value[:length]
 
 
@@ -1179,6 +1180,10 @@ class IProvideClassInfo(IUnknown):
     ]
 
 
+# Flags used to specify the kind of information requested from an object.
+GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1
+
+
 class IProvideClassInfo2(IProvideClassInfo):
     _iid_ = GUID("{A6BC3AC0-DBAA-11CE-9DE3-00AA004BB851}")
     if TYPE_CHECKING:

{comtypes-1.4.10 → comtypes-1.4.11/comtypes.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: comtypes
-Version: 1.4.10
+Version: 1.4.11
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -17,6 +17,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Dynamic: download-url
+Dynamic: license-file
 
 # comtypes
 

{comtypes-1.4.10 → comtypes-1.4.11}/comtypes.egg-info/SOURCES.txt

@@ -93,9 +93,11 @@ comtypes/test/test_dispifc_records.py
 comtypes/test/test_dispifc_safearrays.py
 comtypes/test/test_dispinterface.py
 comtypes/test/test_dyndispatch.py
+comtypes/test/test_errorinfo.py
 comtypes/test/test_excel.py
 comtypes/test/test_findgendir.py
 comtypes/test/test_getactiveobj.py
+comtypes/test/test_hresult.py
 comtypes/test/test_ie.py
 comtypes/test/test_ienum.py
 comtypes/test/test_imfattributes.py

{comtypes-1.4.10 → comtypes-1.4.11}/pyproject.toml

@@ -11,20 +11,15 @@ ignore = ["E402"]
 "comtypes/_npsupport.py" = ["F401"]
 "comtypes/_vtbl.py" = ["E722"]
 "comtypes/automation.py" = ["F401", "F403", "F405"]
-"comtypes/connectionpoints.py" = ["F401", "F403", "F405"]
-"comtypes/errorinfo.py" = ["F403", "F405"]
 "comtypes/git.py" = ["F401", "F403", "F405"]
 "comtypes/util.py" = ["F403", "F405"]
 "comtypes/viewobject.py" = ["F403", "F405"]
-"comtypes/client/_code_cache.py" = ["E401", "E711"]
 "comtypes/client/_constants.py" = ["F401"]
-"comtypes/client/_events.py" = ["F841"]
 "comtypes/server/automation.py" = ["F403", "F405"]
 "comtypes/server/connectionpoints.py" = ["F401", "F403", "F405"]
-"comtypes/server/inprocserver.py" = ["E713", "E722", "F841"]
+"comtypes/server/inprocserver.py" = ["E722"]
 "comtypes/server/register.py" = ["E713"]
 "comtypes/tools/codegenerator/packing.py" = ["F821", "F841"]
-"comtypes/tools/tlbparser.py" = ["F401"]
 "comtypes/tools/typedesc.py" = ["F403", "F405"]
 "comtypes/tools/typedesc_base.py" = ["F401"]
 # gen directory