comtypes 1.4.1__zip → 1.4.3__zip

comtypes-1.4.3/comtypes/test/test_client_regenerate_modules.py

@@ -0,0 +1,158 @@
+import contextlib
+import importlib
+from pathlib import Path
+import shutil
+import sys
+import tempfile
+import types
+from typing import Iterator
+import unittest as ut
+from unittest import mock
+
+import comtypes
+import comtypes.client
+import comtypes.gen
+
+comtypes.client.GetModule("scrrun.dll")
+from comtypes.gen import Scripting  # noqa
+from comtypes.gen import stdole  # noqa
+
+
+SCRRUN_FRIENDLY = Path(Scripting.__file__)
+SCRRUN_WRAPPER = Path(Scripting.__wrapper_module__.__file__)
+STDOLE_FRIENDLY = Path(stdole.__file__)
+STDOLE_WRAPPER = Path(stdole.__wrapper_module__.__file__)
+
+
+@contextlib.contextmanager
+def _mkdtmp_gen_dir() -> Iterator[Path]:
+    with tempfile.TemporaryDirectory() as t:
+        tmp_dir = Path(t)
+        tmp_comtypes_dir = tmp_dir / "comtypes"
+        tmp_comtypes_dir.mkdir()
+        (tmp_comtypes_dir / "__init__.py").touch()
+        tmp_comtypes_gen_dir = tmp_comtypes_dir / "gen"
+        tmp_comtypes_gen_dir.mkdir()
+        (tmp_comtypes_gen_dir / "__init__.py").touch()
+        yield tmp_comtypes_gen_dir
+
+
+@contextlib.contextmanager
+def _patch_gen_pkg(new_path: Path) -> Iterator[types.ModuleType]:
+    new_comtypes_init = (new_path / "comtypes" / "__init__.py").resolve()
+    assert new_comtypes_init.exists()
+    new_comtypes_gen_init = (new_path / "comtypes" / "gen" / "__init__.py").resolve()
+    assert new_comtypes_gen_init.exists()
+    orig_comtypes = sys.modules["comtypes"]
+    orig_gen_names = list(filter(lambda k: k.startswith("comtypes.gen"), sys.modules))
+    tmp_sys_path = list(sys.path)  # copy
+    with mock.patch.object(sys, "path", tmp_sys_path):
+        sys.path.insert(0, str(new_path))
+        with mock.patch.dict(sys.modules):
+            # The reason for removing the parent module (in this case, `comtypes`)
+            # from `sys.modules` is because the child module (in this case,
+            # `comtypes.gen`) refers to the namespace of the parent module.
+            # If the parent module exists in `sys.modules`, Python uses that cache
+            # to import the child module. Therefore, in order to import a new version
+            # of the child module, it is necessary to temporarily remove the parent
+            # module from `sys.modules`.
+            del sys.modules["comtypes"]
+            for k in orig_gen_names:
+                del sys.modules[k]
+            # The module that is imported here is not the one cached in `sys.modules`
+            # before the patch, but the module that is newly loaded from
+            # `new_path / 'comtypes' / 'gen' / '__init__.py'`.
+            new_comtypes_gen = importlib.import_module("comtypes.gen")
+            assert new_comtypes_gen.__file__ is not None
+            assert Path(new_comtypes_gen.__file__).resolve() == new_comtypes_gen_init
+            # The `comtypes` module cached in `sys.modules` as a side effect of
+            # executing the above line is empty because it is the one loaded from
+            # `new_path / 'comtypes' / '__init__.py'`.
+            # If we call the test target as it is, an error will occur due to
+            # referencing an empty module, so we restore the original `comtypes`
+            # to `sys.modules`.
+            sys.modules["comtypes"] = orig_comtypes
+            assert sys.modules["comtypes.gen"] is new_comtypes_gen
+            # By making the empty `comtypes.gen` package we created earlier to be
+            # referenced as the `gen` attribute of `comtypes`, the original
+            # `comtypes.gen` will not be referenced within the context.
+            with mock.patch.object(orig_comtypes, "gen", new_comtypes_gen):
+                yield new_comtypes_gen
+
+
+@contextlib.contextmanager
+def patch_gen_dir() -> Iterator[Path]:
+    with _mkdtmp_gen_dir() as tmp_gen_dir:
+        with mock.patch.object(comtypes.client, "gen_dir", str(tmp_gen_dir)):
+            try:
+                with _patch_gen_pkg(tmp_gen_dir.parent.parent):
+                    yield tmp_gen_dir
+            finally:
+                importlib.invalidate_caches()
+                importlib.reload(comtypes.gen)
+                importlib.reload(stdole)
+                importlib.reload(Scripting)
+
+
+class Test(ut.TestCase):
+    def test_all_modules_are_missing(self):
+        with patch_gen_dir() as gen_dir:
+            # ensure `gen_dir` and `sys.modules` are patched.
+            with self.assertRaises(ImportError):
+                from comtypes.gen import Scripting as _  # noqa
+            self.assertFalse((gen_dir / SCRRUN_FRIENDLY.name).exists())
+            self.assertFalse((gen_dir / SCRRUN_WRAPPER.name).exists())
+            self.assertFalse((gen_dir / STDOLE_FRIENDLY.name).exists())
+            self.assertFalse((gen_dir / STDOLE_WRAPPER.name).exists())
+            # generate new files and modules.
+            comtypes.client.GetModule("scrrun.dll")
+            self.assertTrue((gen_dir / SCRRUN_FRIENDLY.name).exists())
+            self.assertTrue((gen_dir / SCRRUN_WRAPPER.name).exists())
+            self.assertTrue((gen_dir / STDOLE_FRIENDLY.name).exists())
+            self.assertTrue((gen_dir / STDOLE_WRAPPER.name).exists())
+
+    def test_friendly_module_is_missing(self):
+        with patch_gen_dir() as gen_dir:
+            shutil.copy2(SCRRUN_WRAPPER, gen_dir / SCRRUN_WRAPPER.name)
+            wrp_mtime = (gen_dir / SCRRUN_WRAPPER.name).stat().st_mtime_ns
+            shutil.copy2(STDOLE_FRIENDLY, gen_dir / STDOLE_FRIENDLY.name)
+            shutil.copy2(STDOLE_WRAPPER, gen_dir / STDOLE_WRAPPER.name)
+            comtypes.client.GetModule("scrrun.dll")
+            self.assertTrue((gen_dir / SCRRUN_FRIENDLY.name).exists())
+            # Check the most recent content modification time to confirm whether
+            # the module file has been regenerated.
+            self.assertGreater(
+                (gen_dir / SCRRUN_WRAPPER.name).stat().st_mtime_ns, wrp_mtime
+            )
+
+    def test_wrapper_module_is_missing(self):
+        with patch_gen_dir() as gen_dir:
+            shutil.copy2(SCRRUN_WRAPPER, gen_dir / SCRRUN_FRIENDLY.name)
+            frd_mtime = (gen_dir / SCRRUN_FRIENDLY.name).stat().st_mtime_ns
+            shutil.copy2(STDOLE_FRIENDLY, gen_dir / STDOLE_FRIENDLY.name)
+            shutil.copy2(STDOLE_WRAPPER, gen_dir / STDOLE_WRAPPER.name)
+            comtypes.client.GetModule("scrrun.dll")
+            self.assertTrue((gen_dir / SCRRUN_WRAPPER.name).exists())
+            self.assertGreater(
+                (gen_dir / SCRRUN_FRIENDLY.name).stat().st_mtime_ns, frd_mtime
+            )
+
+    def test_dependency_modules_are_missing(self):
+        with patch_gen_dir() as gen_dir:
+            shutil.copy2(SCRRUN_WRAPPER, gen_dir / SCRRUN_FRIENDLY.name)
+            frd_mtime = (gen_dir / SCRRUN_FRIENDLY.name).stat().st_mtime_ns
+            shutil.copy2(SCRRUN_WRAPPER, gen_dir / SCRRUN_WRAPPER.name)
+            wrp_mtime = (gen_dir / SCRRUN_WRAPPER.name).stat().st_mtime_ns
+            comtypes.client.GetModule("scrrun.dll")
+            self.assertTrue((gen_dir / STDOLE_FRIENDLY.name).exists())
+            self.assertTrue((gen_dir / STDOLE_WRAPPER.name).exists())
+            self.assertGreater(
+                (gen_dir / SCRRUN_FRIENDLY.name).stat().st_mtime_ns, frd_mtime
+            )
+            self.assertGreater(
+                (gen_dir / SCRRUN_WRAPPER.name).stat().st_mtime_ns, wrp_mtime
+            )
+
+
+if __name__ == "__main__":
+    ut.main()

comtypes-1.4.3/comtypes/test/test_dispifc_records.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+import unittest
+
+from comtypes import CLSCTX_LOCAL_SERVER
+from comtypes.client import CreateObject, GetModule
+from ctypes import byref, pointer
+
+ComtypesCppTestSrvLib_GUID = "{07D2AEE5-1DF8-4D2C-953A-554ADFD25F99}"
+
+try:
+    GetModule((ComtypesCppTestSrvLib_GUID, 1, 0, 0))
+    import comtypes.gen.ComtypesCppTestSrvLib as ComtypesCppTestSrvLib
+
+    IMPORT_FAILED = False
+except (ImportError, OSError):
+    IMPORT_FAILED = True
+
+
+@unittest.skipIf(IMPORT_FAILED, "This depends on the out of process COM-server.")
+class Test_DispMethods(unittest.TestCase):
+    """Test dispmethods with record and record pointer parameters."""
+
+    EXPECTED_INITED_QUESTIONS = "The meaning of life, the universe and everything?"
+
+    def _create_dispifc(self) -> "ComtypesCppTestSrvLib.IDispRecordParamTest":
+        # Explicitely ask for the dispinterface of the component.
+        return CreateObject(
+            "Comtypes.DispIfcParamTests",
+            clsctx=CLSCTX_LOCAL_SERVER,
+            interface=ComtypesCppTestSrvLib.IDispRecordParamTest,
+        )
+
+    def test_inout_byref(self):
+        dispifc = self._create_dispifc()
+        # Passing a record by reference to a method that has declared the parameter
+        # as [in, out] we expect modifications of the record on the server side to
+        # also change the record on the client side.
+        test_record = ComtypesCppTestSrvLib.StructRecordParamTest()
+        self.assertEqual(test_record.question, None)
+        self.assertEqual(test_record.answer, 0)
+        self.assertEqual(test_record.needs_clarification, False)
+        dispifc.InitRecord(byref(test_record))
+        self.assertEqual(test_record.question, self.EXPECTED_INITED_QUESTIONS)
+        self.assertEqual(test_record.answer, 42)
+        self.assertEqual(test_record.needs_clarification, True)
+
+    def test_inout_pointer(self):
+        dispifc = self._create_dispifc()
+        # Passing a record pointer to a method that has declared the parameter
+        # as [in, out] we expect modifications of the record on the server side to
+        # also change the record on the client side.
+        test_record = ComtypesCppTestSrvLib.StructRecordParamTest()
+        self.assertEqual(test_record.question, None)
+        self.assertEqual(test_record.answer, 0)
+        self.assertEqual(test_record.needs_clarification, False)
+        dispifc.InitRecord(pointer(test_record))
+        self.assertEqual(test_record.question, self.EXPECTED_INITED_QUESTIONS)
+        self.assertEqual(test_record.answer, 42)
+        self.assertEqual(test_record.needs_clarification, True)
+
+    def test_in_record(self):
+        # Passing a record to a method that has declared the parameter just as [in]
+        # we expect modifications of the record on the server side NOT to change
+        # the record on the client side.
+        # We also need to test if the record gets properly passed to the method on
+        # the server side. For this, the 'VerifyRecord' method returns 'True' if
+        # all record fields have values equivalent to the initialization values
+        # provided by 'InitRecord'.
+        inited_record = ComtypesCppTestSrvLib.StructRecordParamTest()
+        inited_record.question = self.EXPECTED_INITED_QUESTIONS
+        inited_record.answer = 42
+        inited_record.needs_clarification = True
+        for rec, expected, (q, a, nc) in [
+            (inited_record, True, (self.EXPECTED_INITED_QUESTIONS, 42, True)),
+            # Also perform the inverted test. For this, create a blank record.
+            (ComtypesCppTestSrvLib.StructRecordParamTest(), False, (None, 0, False)),
+        ]:
+            with self.subTest(expected=expected, q=q, a=a, nc=nc):
+                # Perform the check on initialization values.
+                self.assertEqual(self._create_dispifc().VerifyRecord(rec), expected)
+                self.assertEqual(rec.question, q)
+                # Check if the 'answer' field is unchanged although the method
+                # modifies this field on the server side.
+                self.assertEqual(rec.answer, a)
+                self.assertEqual(rec.needs_clarification, nc)
+
+
+if __name__ == "__main__":
+    unittest.main()

comtypes-1.4.3/comtypes/test/test_findgendir.py

@@ -0,0 +1,87 @@
+import contextlib
+import importlib
+import os
+import sys
+import tempfile
+import types
+from typing import Iterator
+import unittest
+from unittest import mock
+
+import comtypes
+import comtypes.client
+import comtypes.gen
+
+
+IMGBASE = os.path.splitext(os.path.basename(sys.executable))[0]
+
+
+@contextlib.contextmanager
+def patch_empty_module_to_comtypes_gen() -> Iterator[types.ModuleType]:
+    with mock.patch.dict(sys.modules):
+        del sys.modules["comtypes.gen"]
+        mod = sys.modules["comtypes.gen"] = types.ModuleType("comtypes.gen")
+        mod.__path__ = []
+        with mock.patch.object(comtypes, "gen", mod):
+            try:
+                yield mod
+            finally:
+                importlib.reload(comtypes.gen)
+
+
+class Test(unittest.TestCase):
+    """Test the comtypes.client._find_gen_dir() function in several
+    simulated environments.
+    """
+
+    def test_script(self):
+        # %APPDATA%\Python\Python25\comtypes_cache
+        ma, mi = sys.version_info[:2]
+        cache = rf"$APPDATA\Python\Python{ma:d}{mi:d}\comtypes_cache"
+        path = os.path.expandvars(cache)
+        with patch_empty_module_to_comtypes_gen():
+            gen_dir = comtypes.client._find_gen_dir()
+            self.assertEqual(path, gen_dir)
+
+    # patch py2exe-attributes to `sys` modules
+    @mock.patch.object(sys, "frozen", "dll", create=True)
+    @mock.patch.object(sys, "frozendllhandle", sys.dllhandle, create=True)
+    def test_frozen_dll(self):
+        # %TEMP%\comtypes_cache\<imagebasename>25-25
+        # the image is python25.dll
+        ma, mi = sys.version_info[:2]
+        cache = rf"comtypes_cache\{IMGBASE}{ma:d}{mi:d}-{ma:d}{mi:d}"
+        path = os.path.join(tempfile.gettempdir(), cache)
+        with patch_empty_module_to_comtypes_gen():
+            gen_dir = comtypes.client._find_gen_dir()
+            self.assertEqual(path, gen_dir)
+
+    # patch py2exe-attributes to `sys` modules
+    @mock.patch.object(sys, "frozen", "console_exe", create=True)
+    def test_frozen_console_exe(self):
+        # %TEMP%\comtypes_cache\<imagebasename>-25
+        ma, mi = sys.version_info[:2]
+        cache = rf"comtypes_cache\{IMGBASE}-{ma:d}{mi:d}"
+        path = os.path.join(tempfile.gettempdir(), cache)
+        with patch_empty_module_to_comtypes_gen():
+            gen_dir = comtypes.client._find_gen_dir()
+            self.assertEqual(path, gen_dir)
+
+    # patch py2exe-attributes to `sys` modules
+    @mock.patch.object(sys, "frozen", "windows_exe", create=True)
+    def test_frozen_windows_exe(self):
+        # %TEMP%\comtypes_cache\<imagebasename>-25
+        ma, mi = sys.version_info[:2]
+        cache = rf"comtypes_cache\{IMGBASE}-{ma:d}{mi:d}"
+        path = os.path.join(tempfile.gettempdir(), cache)
+        with patch_empty_module_to_comtypes_gen():
+            gen_dir = comtypes.client._find_gen_dir()
+            self.assertEqual(path, gen_dir)
+
+
+def main():
+    unittest.main()
+
+
+if __name__ == "__main__":
+    main()

comtypes-1.4.3/comtypes/tools/codegenerator/__init__.py

@@ -0,0 +1,5 @@
+from comtypes.tools.codegenerator.modulenamer import (  # noqa
+    name_friendly_module,
+    name_wrapper_module,
+)
+from comtypes.tools.codegenerator.codegenerator import CodeGenerator, version  # noqa