comtypes 1.3.1__zip → 1.4.1__zip

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

@@ -1,6 +1,16 @@
 Comtypes CHANGELOG
 ==================
 
+Release 1.4.1
+--------------
+* Fix `TypeError` when defining enumeration types
+
+Release 1.4.0
+--------------
+* Add enumeration definitions in generated friendly modules. By @junkmd.
+* Add descriptions to ``index.rst`` about the enumeration types. By @junkmd.
+* Add GitHub Actions auto-test workflow. By @junkmd.
+
 Release 1.3.1
 --------------
 * Add type annotations to dynamically generated modules. By @junkmd.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.3.1
+Version: 1.4.1
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -67,21 +67,6 @@ But these third-parties are not required as a prerequisite for runtime.
 Tracking issues, reporting bugs and contributing to the codebase and documentation are on GitHub at:
 https://github.com/enthought/comtypes
 
-<a id="ongoing-plans"></a>
-### Ongoing plans
-#### In friendly modules, the names that were used as aliases for `ctypes.c_int` will be used for enumeration types implemented with `enum`
-`comtypes.client.GetModule` generates two `Python` modules in the `comtypes.gen` package with a single call.
-
-A first wrapper module is created with a long name that is derived from the type library guid, version number and lcid. It contains interface classes, coclasses, constants, and structures.  
-A second friendly module is created with a shorter name derived from the type library name itself. It imports items from the wrapper module, and will be the module returned from `GetModule`.
-
-In the current `comtypes` specification, if a COM type kind is defined as an enumeration type, that type name is used as an alias for [`ctypes.c_int`](https://docs.python.org/3/library/ctypes.html#ctypes.c_int) in the wrapper module, and that symbol is imported into the friendly module.  
-In future release, in friendly modules, their names will no longer be aliases for `c_int`. Instead, they will be defined as enumerations implemented with [`enum`](https://docs.python.org/3/library/enum.html).
-
-When imported into the friendly module, the wrapper module will be aliased with an abstracted name (`__wrapper_module__`). This allows users to continue using the old definitions by modifying the import sections of their codebase.
-
-Please refer to [the GitHub issue](https://github.com/enthought/comtypes/issues/345) for details.
-
 ## For Enterprise
 
 Available as part of the Tidelift Subscription.

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

@@ -48,21 +48,6 @@ But these third-parties are not required as a prerequisite for runtime.
 Tracking issues, reporting bugs and contributing to the codebase and documentation are on GitHub at:
 https://github.com/enthought/comtypes
 
-<a id="ongoing-plans"></a>
-### Ongoing plans
-#### In friendly modules, the names that were used as aliases for `ctypes.c_int` will be used for enumeration types implemented with `enum`
-`comtypes.client.GetModule` generates two `Python` modules in the `comtypes.gen` package with a single call.
-
-A first wrapper module is created with a long name that is derived from the type library guid, version number and lcid. It contains interface classes, coclasses, constants, and structures.  
-A second friendly module is created with a shorter name derived from the type library name itself. It imports items from the wrapper module, and will be the module returned from `GetModule`.
-
-In the current `comtypes` specification, if a COM type kind is defined as an enumeration type, that type name is used as an alias for [`ctypes.c_int`](https://docs.python.org/3/library/ctypes.html#ctypes.c_int) in the wrapper module, and that symbol is imported into the friendly module.  
-In future release, in friendly modules, their names will no longer be aliases for `c_int`. Instead, they will be defined as enumerations implemented with [`enum`](https://docs.python.org/3/library/enum.html).
-
-When imported into the friendly module, the wrapper module will be aliased with an abstracted name (`__wrapper_module__`). This allows users to continue using the old definitions by modifying the import sections of their codebase.
-
-Please refer to [the GitHub issue](https://github.com/enthought/comtypes/issues/345) for details.
-
 ## For Enterprise
 
 Available as part of the Tidelift Subscription.

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

@@ -1,5 +1,5 @@
 # comtypes version numbers follow semver (http://semver.org/) and PEP 440
-__version__ = "1.3.1"
+__version__ = "1.4.1"
 
 import atexit
 from ctypes import *

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

@@ -74,6 +74,16 @@ class Test_GetModule(ut.TestCase):
         # NOTE: `WindowsInstaller`, which has `Patch` definition in dll.
         comtypes.client.GetModule("msi.dll")
 
+    def test_the_name_of_the_enum_member_and_the_coclass_are_duplicated(self):
+        # NOTE: In `MSHTML`, the name `htmlInputImage` is used both as a member of
+        # the `_htmlInput` enum type and as a CoClass that has `IHTMLElement` and
+        # others as interfaces.
+        # If a CoClass is assigned where an integer should be assigned, such as in
+        # 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")
+
     def test_abstracted_wrapper_module_in_friendly_module(self):
         mod = comtypes.client.GetModule("scrrun.dll")
         self.assertTrue(hasattr(mod, "__wrapper_module__"))
@@ -229,6 +239,15 @@ class Test_Constants(ut.TestCase):
         self.assertEqual(consts.TextCompare, Scripting.TextCompare)
         self.assertEqual(consts.DatabaseCompare, Scripting.DatabaseCompare)
 
+    def test_enums_in_friendly_mod(self):
+        consts = comtypes.client.Constants("scrrun.dll")
+        comtypes.client.GetModule("scrrun.dll")
+        from comtypes.gen import Scripting
+
+        for e in Scripting.StandardStreamTypes:
+            self.assertIn(e.name, consts.StandardStreamTypes)
+            self.assertEqual(consts.StandardStreamTypes[e.name], e.value)
+
     def test_returns_other_than_enum_members(self):
         obj = comtypes.client.CreateObject("SAPI.SpVoice")
         from comtypes.gen import SpeechLib as sapi

{comtypes-1.3.1 → comtypes-1.4.1}/comtypes/tools/codegenerator.py

@@ -423,12 +423,14 @@ class CodeGenerator(object):
         self.stream = io.StringIO()
         self.imports = ImportedNamespaces()
         self.declarations = DeclaredNamespaces()
+        self.enums = EnumerationNamespaces()
         self._to_type_name = TypeNamer()
         self.known_symbols = known_symbols or {}
 
         self.done = set()  # type descriptions that have been generated
         self.names = set()  # names that have been generated
         self.externals = []  # typelibs imported to generated module
+        self.aliases: Dict[str, str] = {}
         self.last_item_class = False
 
     def generate(self, item):
@@ -571,14 +573,7 @@ class CodeGenerator(object):
         print(self.declarations.getvalue(), file=output)
         print(file=output)
         print(self.stream.getvalue(), file=output)
-        names = ", ".join(repr(str(n)) for n in self.names)
-        dunder_all = "__all__ = [%s]" % names
-        if len(dunder_all) > 80:
-            wrapper = textwrap.TextWrapper(
-                subsequent_indent="    ", initial_indent="    ", break_long_words=False
-            )
-            dunder_all = "__all__ = [\n%s\n]" % "\n".join(wrapper.wrap(names))
-        print(dunder_all, file=output)
+        print(self._make_dunder_all_part(), file=output)
         print(file=output)
         if tlib_mtime is not None:
             print("_check_version(%r, %f)" % (version, tlib_mtime), file=output)
@@ -595,29 +590,59 @@ class CodeGenerator(object):
         Such as "comtypes.gen.stdole" and "comtypes.gen.Excel".
         """
         output = io.StringIO()
+        print("from enum import IntFlag", file=output)
+        print(file=output)
         print(f"import {modname} as __wrapper_module__", file=output)
-        txtwrapper = textwrap.TextWrapper(
-            subsequent_indent="    ", initial_indent="    ", break_long_words=False
-        )
-        importing_symbols = set(self.names)
-        importing_symbols.update(self.imports.get_symbols())
-        importing_symbols.update(self.declarations.get_symbols())
-        joined_names = ", ".join(str(n) for n in importing_symbols)
-        symbols = f"from {modname} import {joined_names}"
-        if len(symbols) > 80:
-            wrapped_names = "\n".join(txtwrapper.wrap(joined_names))
-            symbols = f"from {modname} import (\n{wrapped_names}\n)"
-        print(symbols, file=output)
+        print(self._make_friendly_module_import_part(modname), file=output)
         print(file=output)
         print(file=output)
-        quoted_names = ", ".join(repr(str(n)) for n in self.names)
-        dunder_all = f"__all__ = [{quoted_names}]"
-        if len(dunder_all) > 80:
-            wrapped_quoted_names = "\n".join(txtwrapper.wrap(quoted_names))
-            dunder_all = f"__all__ = [\n{wrapped_quoted_names}\n]"
-        print(dunder_all, file=output)
+        print(self.enums.getvalue(), file=output)
+        print(file=output)
+        print(file=output)
+        enum_aliases = self.enum_aliases
+        if enum_aliases:
+            for k, v in enum_aliases.items():
+                print(f"{k} = {v}", file=output)
+            print(file=output)
+            print(file=output)
+        print(self._make_dunder_all_part(), file=output)
         return output.getvalue()
 
+    def _make_dunder_all_part(self) -> str:
+        joined_names = ", ".join(repr(str(n)) for n in self.names)
+        dunder_all = f"__all__ = [{joined_names}]"
+        if len(dunder_all) > 80:
+            txtwrapper = textwrap.TextWrapper(
+                subsequent_indent="    ", initial_indent="    ", break_long_words=False
+            )
+            joined_names = "\n".join(txtwrapper.wrap(joined_names))
+            dunder_all = f"__all__ = [\n{joined_names}\n]"
+        return dunder_all
+
+    def _make_friendly_module_import_part(self, modname: str) -> str:
+        # The `modname` is the wrapper module name like `comtypes.gen._xxxx..._x_x_x`
+        txtwrapper = textwrap.TextWrapper(
+            subsequent_indent="    ", initial_indent="    ", break_long_words=False
+        )
+        symbols = set(self.names)
+        symbols.update(self.imports.get_symbols())
+        symbols.update(self.declarations.get_symbols())
+        symbols -= set(self.enums.get_symbols())
+        symbols -= set(self.enum_aliases)
+        joined_names = ", ".join(str(n) for n in symbols)
+        part = f"from {modname} import {joined_names}"
+        if len(part) > 80:
+            txtwrapper = textwrap.TextWrapper(
+                subsequent_indent="    ", initial_indent="    ", break_long_words=False
+            )
+            joined_names = "\n".join(txtwrapper.wrap(joined_names))
+            part = f"from {modname} import (\n{joined_names}\n)"
+        return part
+
+    @property
+    def enum_aliases(self) -> Dict[str, str]:
+        return {k: v for k, v in self.aliases.items() if v in self.enums}
+
     def need_VARIANT_imports(self, value):
         text = repr(value)
         if "Decimal(" in text:
@@ -645,6 +670,8 @@ class CodeGenerator(object):
                 print("# Fixing keyword as EnumValue for %s" % tp.name)
         tp_name = self._to_type_name(tp)
         print("%s = %d" % (tp_name, value), file=self.stream)
+        if tp.enumeration.name:
+            self.enums.add(tp.enumeration.name, tp_name, value)
         self.names.add(tp_name)
 
     def Enumeration(self, tp: typedesc.Enumeration) -> None:
@@ -653,10 +680,6 @@ class CodeGenerator(object):
             print("# values for enumeration '%s'" % tp.name, file=self.stream)
         else:
             print("# values for unnamed enumeration", file=self.stream)
-        # Some enumerations have the same name for the enum type
-        # and an enum value.  Excel's XlDisplayShapes is such an example.
-        # Since we don't have separate namespaces for the type and the values,
-        # we generate the TYPE last, overwriting the value. XXX
         for item in tp.values:
             self.generate(item)
         if tp.name:
@@ -675,6 +698,7 @@ class CodeGenerator(object):
                 self.declarations.add(tp.name, definition)
             else:
                 print("%s = %s" % (tp.name, definition), file=self.stream)
+                self.aliases[tp.name] = definition
                 self.last_item_class = False
         self.names.add(tp.name)
 
@@ -1518,3 +1542,45 @@ class DeclaredNamespaces(object):
                 code = code + "  # %s" % comment
             lines.append(code)
         return "\n".join(lines)
+
+
+class EnumerationNamespaces(object):
+    def __init__(self):
+        self.data: Dict[str, List[Tuple[str, int]]] = {}
+
+    def add(self, enum_name: str, member_name: str, value: int) -> None:
+        """Adds a namespace will be enumeration and its member.
+
+        Examples:
+            >>> enums = EnumerationNamespaces()
+            >>> enums.add('Foo', 'ham', 1)
+            >>> enums.add('Foo', 'spam', 2)
+            >>> enums.add('Bar', 'bacon', 3)
+            >>> assert 'Foo' in enums
+            >>> assert 'Baz' not in enums
+            >>> print(enums.getvalue())  # <BLANKLINE> is necessary for doctest
+            class Foo(IntFlag):
+                ham = 1
+                spam = 2
+            <BLANKLINE>
+            <BLANKLINE>
+            class Bar(IntFlag):
+                bacon = 3
+        """
+        self.data.setdefault(enum_name, []).append((member_name, value))
+
+    def __contains__(self, item: str) -> bool:
+        return item in self.data
+
+    def get_symbols(self) -> Set[str]:
+        return set(self.data)
+
+    def getvalue(self) -> str:
+        blocks = []
+        for enum_name, enum_members in self.data.items():
+            lines = []
+            lines.append(f"class {enum_name}(IntFlag):")
+            for member_name, value in enum_members:
+                lines.append(f"    {member_name} = {value}")
+            blocks.append("\n".join(lines))
+        return "\n\n\n".join(blocks)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: comtypes
-Version: 1.3.1
+Version: 1.4.1
 Summary: Pure Python COM package
 Home-page: https://github.com/enthought/comtypes
 Download-URL: https://github.com/enthought/comtypes/releases
@@ -67,21 +67,6 @@ But these third-parties are not required as a prerequisite for runtime.
 Tracking issues, reporting bugs and contributing to the codebase and documentation are on GitHub at:
 https://github.com/enthought/comtypes
 
-<a id="ongoing-plans"></a>
-### Ongoing plans
-#### In friendly modules, the names that were used as aliases for `ctypes.c_int` will be used for enumeration types implemented with `enum`
-`comtypes.client.GetModule` generates two `Python` modules in the `comtypes.gen` package with a single call.
-
-A first wrapper module is created with a long name that is derived from the type library guid, version number and lcid. It contains interface classes, coclasses, constants, and structures.  
-A second friendly module is created with a shorter name derived from the type library name itself. It imports items from the wrapper module, and will be the module returned from `GetModule`.
-
-In the current `comtypes` specification, if a COM type kind is defined as an enumeration type, that type name is used as an alias for [`ctypes.c_int`](https://docs.python.org/3/library/ctypes.html#ctypes.c_int) in the wrapper module, and that symbol is imported into the friendly module.  
-In future release, in friendly modules, their names will no longer be aliases for `c_int`. Instead, they will be defined as enumerations implemented with [`enum`](https://docs.python.org/3/library/enum.html).
-
-When imported into the friendly module, the wrapper module will be aliased with an abstracted name (`__wrapper_module__`). This allows users to continue using the old definitions by modifying the import sections of their codebase.
-
-Please refer to [the GitHub issue](https://github.com/enthought/comtypes/issues/345) for details.
-
 ## For Enterprise
 
 Available as part of the Tidelift Subscription.