py2docfx 0.1.13.dev2016838__py3-none-any.whl → 0.1.13.dev2021865__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/win32com/client/__init__.py

@@ -5,8 +5,10 @@
 # Note that if the unknown dispatch object then returns a known
 # dispatch object, the known class will be used.  This contrasts
 # with dynamic.Dispatch behaviour, where dynamic objects are always used.
+from __future__ import annotations
 
 import sys
+from itertools import chain
 
 import pythoncom
 import pywintypes
@@ -262,7 +264,39 @@ class EventsProxy:
         setattr(self._obj_, attr, val)
 
 
-def DispatchWithEvents(clsid, user_event_class):
+def __get_disp_and_event_classes(dispatch):
+    # Create/Get the object.
+    disp = Dispatch(dispatch)
+
+    if disp.__class__.__dict__.get("CLSID"):
+        return disp.__class__
+
+    # Eeek - no makepy support - try and build it.
+    error_msg = "This COM object can not automate the makepy process - please run makepy manually for this object"
+    try:
+        ti = disp._oleobj_.GetTypeInfo()
+        disp_clsid = ti.GetTypeAttr()[0]
+        tlb, index = ti.GetContainingTypeLib()
+        tla = tlb.GetLibAttr()
+        gencache.EnsureModule(tla[0], tla[1], tla[3], tla[4], bValidateFile=0)
+        # Get the class from the module.
+        disp_class = gencache.GetClassForProgID(str(disp_clsid))
+    except pythoncom.com_error as error:
+        raise TypeError(error_msg) from error
+
+    if disp_class is None:
+        raise TypeError(error_msg)
+    # Get the clsid
+    clsid = disp_class.CLSID
+    # Create a new class that derives from 2 classes:
+    # the event sink class and the user class.
+    events_class = getevents(clsid)
+    if events_class is None:
+        raise ValueError("This COM object does not support events.")
+    return disp, disp_class, events_class
+
+
+def DispatchWithEvents(clsid, user_event_class) -> EventsProxy:
     """Create a COM object that can fire events to a user defined class.
     clsid -- The ProgID or CLSID of the object to create.
     user_event_class -- A Python class object that responds to the events.
@@ -301,39 +335,14 @@ def DispatchWithEvents(clsid, user_event_class):
     Visible changed: 1
     >>>
     """
-    # Create/Get the object.
-    disp = Dispatch(clsid)
-    if not disp.__class__.__dict__.get(
-        "CLSID"
-    ):  # Eeek - no makepy support - try and build it.
-        try:
-            ti = disp._oleobj_.GetTypeInfo()
-            disp_clsid = ti.GetTypeAttr()[0]
-            tlb, index = ti.GetContainingTypeLib()
-            tla = tlb.GetLibAttr()
-            gencache.EnsureModule(tla[0], tla[1], tla[3], tla[4], bValidateFile=0)
-            # Get the class from the module.
-            disp_class = gencache.GetClassForProgID(str(disp_clsid))
-        except pythoncom.com_error:
-            raise TypeError(
-                "This COM object can not automate the makepy process - please run makepy manually for this object"
-            )
-    else:
-        disp_class = disp.__class__
-    # If the clsid was an object, get the clsid
-    clsid = disp_class.CLSID
-    # Create a new class that derives from 3 classes - the dispatch class, the event sink class and the user class.
-    events_class = getevents(clsid)
-    if events_class is None:
-        raise ValueError("This COM object does not support events.")
+    disp, disp_class, events_class = __get_disp_and_event_classes(clsid)
     result_class = type(
         "COMEventClass",
         (disp_class, events_class, user_event_class),
         {"__setattr__": _event_setattr_},
     )
-    instance = result_class(
-        disp._oleobj_
-    )  # This only calls the first base class __init__.
+    # This only calls the first base class __init__.
+    instance = result_class(disp._oleobj_)
     events_class.__init__(instance, instance)
     if hasattr(user_event_class, "__init__"):
         user_event_class.__init__(instance)
@@ -364,33 +373,14 @@ def WithEvents(disp, user_event_class):
     This is mainly useful where using DispatchWithEvents causes
     circular reference problems that the simple proxy doesn't deal with
     """
-    disp = Dispatch(disp)
-    if not disp.__class__.__dict__.get(
-        "CLSID"
-    ):  # Eeek - no makepy support - try and build it.
-        try:
-            ti = disp._oleobj_.GetTypeInfo()
-            disp_clsid = ti.GetTypeAttr()[0]
-            tlb, index = ti.GetContainingTypeLib()
-            tla = tlb.GetLibAttr()
-            gencache.EnsureModule(tla[0], tla[1], tla[3], tla[4], bValidateFile=0)
-            # Get the class from the module.
-            disp_class = gencache.GetClassForProgID(str(disp_clsid))
-        except pythoncom.com_error:
-            raise TypeError(
-                "This COM object can not automate the makepy process - please run makepy manually for this object"
-            )
-    else:
-        disp_class = disp.__class__
-    # Get the clsid
-    clsid = disp_class.CLSID
-    # Create a new class that derives from 2 classes - the event sink
-    # class and the user class.
-    events_class = getevents(clsid)
-    if events_class is None:
-        raise ValueError("This COM object does not support events.")
-    result_class = type("COMEventClass", (events_class, user_event_class), {})
-    instance = result_class(disp)  # This only calls the first base class __init__.
+    disp, disp_class, events_class = __get_disp_and_event_classes(disp)
+    result_class = type(
+        "COMEventClass",
+        (events_class, user_event_class),
+        {},
+    )
+    # This only calls the first base class __init__.
+    instance = result_class(disp)
     if hasattr(user_event_class, "__init__"):
         user_event_class.__init__(instance)
     return instance
@@ -486,6 +476,47 @@ def Record(name, object):
     )
 
 
+# Registration function for com_record subclasses.
+def register_record_class(cls):
+    """
+    Register a subclass of com_record to enable creation of the represented record objects.
+
+    A subclass of com_record requires the following class attributes to be instantiable:
+
+        TLBID : The GUID of the containing TypeLibrary as a string.
+        MJVER : The major version number of the TypeLibrary as an integer.
+        MNVER : The minor version number of the TypeLibrary as an integer.
+        LCID  : The LCID of the TypeLibrary as an integer.
+        GUID  : The GUID of the COM Record as a string.
+
+    with GUID strings in {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} notation.
+
+    To instantiate such a subclasses it has to be registered via this function.
+    """
+    if not issubclass(cls, pythoncom.com_record):
+        raise TypeError("Only subclasses of 'com_record' can be registered.")
+    try:
+        TLBID = cls.TLBID
+        MJVER = cls.MJVER
+        MNVER = cls.MNVER
+        LCID = cls.LCID
+        GUID = cls.GUID
+    except AttributeError as e:
+        raise AttributeError(f"Class {cls.__name__} cannot be instantiated.") from e
+    try:
+        _ = pythoncom.GetRecordFromGuids(TLBID, MJVER, MNVER, LCID, GUID)
+    except Exception as e:
+        raise TypeError(f"Class {cls.__name__} cannot be instantiated.") from e
+    # Since the class can be instantiated we know that it represents a valid COM Record
+    # in a properly registered TypeLibrary and that it has a 'GUID' class attribute.
+    if cls.GUID in pythoncom.RecordClasses:
+        raise ValueError(
+            f"Record class with same GUID {cls.GUID} "
+            f"is already registered with name '{pythoncom.RecordClasses[cls.GUID].__name__}'."
+        )
+    pythoncom.RecordClasses[cls.GUID] = cls
+
+
 ############################################
 # The base of all makepy generated classes
 ############################################
@@ -510,17 +541,18 @@ class DispatchBaseClass:
         self.__dict__["_oleobj_"] = oobj  # so we don't call __setattr__
 
     def __dir__(self):
-        lst = (
-            list(self.__dict__.keys())
-            + dir(self.__class__)
-            + list(self._prop_map_get_.keys())
-            + list(self._prop_map_put_.keys())
+        attributes = chain(
+            self.__dict__,
+            dir(self.__class__),
+            self._prop_map_get_,
+            self._prop_map_put_,
         )
+
         try:
-            lst += [p.Name for p in self.Properties_]
+            attributes = chain(attributes, [p.Name for p in self.Properties_])
         except AttributeError:
             pass
-        return list(set(lst))
+        return list(set(attributes))
 
     # Provide a prettier name than the CLSID
     def __repr__(self):
@@ -554,7 +586,7 @@ class DispatchBaseClass:
     def __getattr__(self, attr):
         args = self._prop_map_get_.get(attr)
         if args is None:
-            raise AttributeError(f"'{repr(self)}' object has no attribute '{attr}'")
+            raise AttributeError(f"'{self!r}' object has no attribute '{attr}'")
         return self._ApplyTypes_(*args)
 
     def __setattr__(self, attr, value):
@@ -564,7 +596,7 @@ class DispatchBaseClass:
         try:
             args, defArgs = self._prop_map_put_[attr]
         except KeyError:
-            raise AttributeError(f"'{repr(self)}' object has no attribute '{attr}'")
+            raise AttributeError(f"'{self!r}' object has no attribute '{attr}'")
         self._oleobj_.Invoke(*(args + (value,) + defArgs))
 
     def _get_good_single_object_(self, obj, obUserName=None, resultCLSID=None):

py2docfx/venv/venv1/Lib/site-packages/win32com/client/build.py

@@ -16,8 +16,10 @@ dynamically, or possibly even generate .html documentation for objects.
 #
 #        OleItem, DispatchItem, MapEntry, BuildCallList() is used by makepy
 
+import builtins
 import datetime
 import string
+from itertools import chain
 from keyword import iskeyword
 
 import pythoncom
@@ -113,9 +115,8 @@ class MapEntry:
         rc = self.GetResultCLSID()
         if rc is None:
             return "None"
-        return repr(
-            str(rc)
-        )  # Convert the IID object to a string, then to a string in a string.
+        # Convert the IID object to a string in a string.
+        return f"'{rc}'"
 
     def GetResultName(self):
         if self.resultDocumentation is None:
@@ -403,7 +404,7 @@ class DispatchItem(OleItem):
         if len(bad_params) == 0 and len(retDesc) == 2 and retDesc[1] == 0:
             rd = retDesc[0]
             if rd in NoTranslateMap:
-                s = "%s\treturn self._oleobj_.InvokeTypes(%d, LCID, %s, %s, %s%s)" % (
+                s = "{}\treturn self._oleobj_.InvokeTypes({}, LCID, {}, {}, {}{})".format(
                     linePrefix,
                     id,
                     fdesc[4],
@@ -412,12 +413,12 @@ class DispatchItem(OleItem):
                     _BuildArgList(fdesc, names),
                 )
             elif rd in [pythoncom.VT_DISPATCH, pythoncom.VT_UNKNOWN]:
-                s = "%s\tret = self._oleobj_.InvokeTypes(%d, LCID, %s, %s, %s%s)\n" % (
+                s = "{}\tret = self._oleobj_.InvokeTypes({}, LCID, {}, {}, {!r}{})\n".format(
                     linePrefix,
                     id,
                     fdesc[4],
                     retDesc,
-                    repr(argsDesc),
+                    argsDesc,
                     _BuildArgList(fdesc, names),
                 )
                 s += f"{linePrefix}\tif ret is not None:\n"
@@ -431,29 +432,27 @@ class DispatchItem(OleItem):
                     )
                     s += f"{linePrefix}\t\texcept pythoncom.error:\n"
                     s += f"{linePrefix}\t\t\treturn ret\n"
-                s += "{}\t\tret = Dispatch(ret, {}, {})\n".format(
-                    linePrefix, repr(name), resclsid
-                )
-                s += "%s\treturn ret" % linePrefix
+                s += f"{linePrefix}\t\tret = Dispatch(ret, {name!r}, {resclsid})\n"
+                s += f"{linePrefix}\treturn ret"
             elif rd == pythoncom.VT_BSTR:
                 s = f"{linePrefix}\t# Result is a Unicode object\n"
-                s += "%s\treturn self._oleobj_.InvokeTypes(%d, LCID, %s, %s, %s%s)" % (
+                s += "{}\treturn self._oleobj_.InvokeTypes({}, LCID, {}, {}, {!r}{})".format(
                     linePrefix,
                     id,
                     fdesc[4],
                     retDesc,
-                    repr(argsDesc),
+                    argsDesc,
                     _BuildArgList(fdesc, names),
                 )
             # else s remains None
         if s is None:
-            s = "%s\treturn self._ApplyTypes_(%d, %s, %s, %s, %s, %s%s)" % (
+            s = "{}\treturn self._ApplyTypes_({}, {}, {}, {}, {!r}, {}{})".format(
                 linePrefix,
                 id,
                 fdesc[4],
                 retDesc,
                 argsDesc,
-                repr(name),
+                name,
                 resclsid,
                 _BuildArgList(fdesc, names),
             )
@@ -493,18 +492,20 @@ class VTableItem(DispatchItem):
         DispatchItem.Build(self, typeinfo, attr, bForUser)
         assert typeinfo is not None, "Can't build vtables without type info!"
 
-        meth_list = (
-            list(self.mapFuncs.values())
-            + list(self.propMapGet.values())
-            + list(self.propMapPut.values())
+        meth_list = sorted(
+            chain(
+                self.mapFuncs.values(),
+                self.propMapGet.values(),
+                self.propMapPut.values(),
+            ),
+            key=lambda m: m.desc[7],
         )
-        meth_list.sort(key=lambda m: m.desc[7])
 
         # Now turn this list into the run-time representation
         # (ready for immediate use or writing to gencache)
-        self.vtableFuncs = []
-        for entry in meth_list:
-            self.vtableFuncs.append((entry.names, entry.dispid, entry.desc))
+        self.vtableFuncs = [
+            (entry.names, entry.dispid, entry.desc) for entry in meth_list
+        ]
 
 
 # A Lazy dispatch item - builds an item on request using info from
@@ -545,7 +546,6 @@ def _ResolveType(typerepr, itypeinfo):
             if was_user and subrepr in [
                 pythoncom.VT_DISPATCH,
                 pythoncom.VT_UNKNOWN,
-                pythoncom.VT_RECORD,
             ]:
                 # Drop the VT_PTR indirection
                 return subrepr, sub_clsid, sub_doc
@@ -654,7 +654,7 @@ def MakePublicAttributeName(className, is_global=False):
         if ret == className:
             ret = ret.upper()
         return ret
-    elif is_global and hasattr(__builtins__, className):
+    elif is_global and hasattr(builtins, className):
         # builtins may be mixed case.  If capitalizing it doesn't change it,
         # force to all uppercase (eg, "None", "True" become "NONE", "TRUE"
         ret = className.capitalize()

py2docfx/venv/venv1/Lib/site-packages/win32com/client/combrowse.py

@@ -1,25 +1,25 @@
 """A utility for browsing COM objects.
 
- Usage:
+Usage:
 
-  Command Prompt
+ Command Prompt
 
-    Use the command *"python.exe combrowse.py"*.  This will display
-    display a fairly small, modal dialog.
+   Use the command *"python.exe combrowse.py"*.  This will display
+   display a fairly small, modal dialog.
 
-  Pythonwin
+ Pythonwin
 
-    Use the "Run Script" menu item, and this will create the browser in an
-    MDI window.  This window can be fully resized.
+   Use the "Run Script" menu item, and this will create the browser in an
+   MDI window.  This window can be fully resized.
 
- Details
+Details
 
-   This module allows browsing of registered Type Libraries, COM categories,
-   and running COM objects.  The display is similar to the Pythonwin object
-   browser, and displays the objects in a hierarchical window.
+  This module allows browsing of registered Type Libraries, COM categories,
+  and running COM objects.  The display is similar to the Pythonwin object
+  browser, and displays the objects in a hierarchical window.
 
-   Note that this module requires the win32ui (ie, Pythonwin) distribution to
-   work.
+  Note that this module requires the win32ui (ie, Pythonwin) distribution to
+  work.
 
 """
 
@@ -93,8 +93,6 @@ class HLI_Enum(HLI_Interface):
             rc = 0
         return rc
 
-    pass
-
 
 class HLI_IEnumMoniker(HLI_Enum):
     def GetSubList(self):
@@ -265,10 +263,7 @@ class HLITypeLibEntry(HLICOM):
     def GetText(self):
         tlb, index = self.myobject
         name, doc, ctx, helpFile = tlb.GetDocumentation(index)
-        try:
-            typedesc = HLITypeKinds[tlb.GetTypeInfoType(index)][1]
-        except KeyError:
-            typedesc = "Unknown!"
+        typedesc = HLITypeKinds.get(tlb.GetTypeInfoType(index), (None, "Unknown!"))[1]
         return name + " - " + typedesc
 
     def GetSubList(self):
@@ -448,10 +443,7 @@ class HLITypeLibFunction(HLICOM):
 
     def MakeReturnTypeName(self, typ):
         justtyp = typ & pythoncom.VT_TYPEMASK
-        try:
-            typname = self.vartypes[justtyp]
-        except KeyError:
-            typname = "?Bad type?"
+        typname = self.vartypes.get(justtyp, "?Bad type?")
         for flag, desc in self.type_flags:
             if flag & typ:
                 typname = f"{desc}({typname})"
@@ -493,15 +485,9 @@ class HLITypeLibFunction(HLICOM):
                 val += f" (Default={default})"
             ret.append(browser.MakeHLI(val, "Argument"))
 
-        try:
-            fkind = self.funckinds[fd[3]]
-        except KeyError:
-            fkind = "Unknown"
+        fkind = self.funckinds.get(fd[3], "Unknown")
         ret.append(browser.MakeHLI(fkind, "Function Kind"))
-        try:
-            ikind = self.invokekinds[fd[4]]
-        except KeyError:
-            ikind = "Unknown"
+        ikind = self.invokekinds.get([fd[4]], "Unknown")
         ret.append(browser.MakeHLI(ikind, "Invoke Kind"))
         # 5 = call conv
         # 5 = offset vtbl
@@ -595,8 +581,6 @@ class HLIHeadingRegisterdTypeLibs(HLICOM):
 
 
 def main(modal=True, mdi=False):
-    from pywin.tools import hierlist
-
     root = HLIRoot("COM Browser")
     if mdi and "pywin.framework.app" in sys.modules:
         # do it in a MDI window

py2docfx/venv/venv1/Lib/site-packages/win32com/client/dynamic.py

@@ -17,6 +17,7 @@ Example
 """
 
 import traceback
+from itertools import chain
 from types import MethodType
 
 import pythoncom  # Needed as code we eval() references it.
@@ -233,19 +234,19 @@ class CDispatch:
             return self.__repr__()
 
     def __dir__(self):
-        lst = list(self.__dict__.keys()) + dir(self.__class__) + self._dir_ole_()
+        attributes = chain(self.__dict__, dir(self.__class__), self._dir_ole_())
         try:
-            lst += [p.Name for p in self.Properties_]
+            attributes = chain(attributes, [p.Name for p in self.Properties_])
         except AttributeError:
             pass
-        return list(set(lst))
+        return list(set(attributes))
 
     def _dir_ole_(self):
         items_dict = {}
         for iTI in range(0, self._oleobj_.GetTypeInfoCount()):
             typeInfo = self._oleobj_.GetTypeInfo(iTI)
             self._UpdateWithITypeInfo_(items_dict, typeInfo)
-        return list(items_dict.keys())
+        return list(items_dict)
 
     def _UpdateWithITypeInfo_(self, items_dict, typeInfo):
         typeInfos = [typeInfo]
@@ -388,9 +389,10 @@ class CDispatch:
         elif isinstance(ob, tuple):
             return tuple(
                 map(
-                    lambda o, s=self, oun=userName, rc=ReturnCLSID: s._get_good_single_object_(
-                        o, oun, rc
-                    ),
+                    lambda o,
+                    s=self,
+                    oun=userName,
+                    rc=ReturnCLSID: s._get_good_single_object_(o, oun, rc),
                     ob,
                 )
             )
@@ -455,17 +457,17 @@ class CDispatch:
         print("AxDispatch container", self._username_)
         try:
             print("Methods:")
-            for method in self._olerepr_.mapFuncs.keys():
+            for method in self._olerepr_.mapFuncs:
                 print("\t", method)
             print("Props:")
             for prop, entry in self._olerepr_.propMap.items():
-                print(f"\t{prop} = 0x{entry.dispid:x} - {repr(entry)}")
+                print(f"\t{prop} = 0x{entry.dispid:x} - {entry!r}")
             print("Get Props:")
             for prop, entry in self._olerepr_.propMapGet.items():
-                print(f"\t{prop} = 0x{entry.dispid:x} - {repr(entry)}")
+                print(f"\t{prop} = 0x{entry.dispid:x} - {entry!r}")
             print("Put Props:")
             for prop, entry in self._olerepr_.propMapPut.items():
-                print(f"\t{prop} = 0x{entry.dispid:x} - {repr(entry)}")
+                print(f"\t{prop} = 0x{entry.dispid:x} - {entry!r}")
         except:
             traceback.print_exc()
 
@@ -638,9 +640,7 @@ class CDispatch:
             return
         # Allow property assignment.
         debug_attr_print(
-            "SetAttr called for {}.{}={} on DispatchContainer".format(
-                self._username_, attr, repr(value)
-            )
+            f"SetAttr called for {self._username_}.{attr}={value!r} on DispatchContainer"
         )
 
         if self._olerepr_:

py2docfx/venv/venv1/Lib/site-packages/win32com/client/gencache.py

@@ -23,6 +23,7 @@ Hacks, to do, etc
 
 from __future__ import annotations
 
+import contextlib
 import glob
 import os
 import sys
@@ -34,6 +35,7 @@ import pythoncom
 import pywintypes
 import win32com
 import win32com.client
+import win32event
 
 from . import CLSIDToClass
 
@@ -133,6 +135,22 @@ def _LoadDicts():
         f.close()
 
 
+@contextlib.contextmanager
+def ModuleMutex(module_name):
+    """Given the output of GetGeneratedFilename, acquire a named mutex for that module
+
+    This is required so that writes (generation) don't interfere with each other and with reads (import)
+    """
+    mutex = win32event.CreateMutex(None, False, module_name)
+    with contextlib.closing(mutex):
+        # acquire mutex
+        win32event.WaitForSingleObject(mutex, win32event.INFINITE)
+        try:
+            yield
+        finally:
+            win32event.ReleaseMutex(mutex)
+
+
 def GetGeneratedFileName(clsid, lcid, major, minor):
     """Given the clsid, lcid, major and  minor for a type lib, return
     the file name (no extension) providing this support.
@@ -258,7 +276,8 @@ def GetModuleForCLSID(clsid):
         if sub_mod is not None:
             sub_mod_name = mod.__name__ + "." + sub_mod
             try:
-                __import__(sub_mod_name)
+                with ModuleMutex(mod.__name__.split(".")[-1]):
+                    __import__(sub_mod_name)
             except ImportError:
                 info = typelibCLSID, lcid, major, minor
                 # Force the generation.  If this typelibrary has explicitly been added,
@@ -420,7 +439,7 @@ def ForgetAboutTypelibInterface(typelib_ob):
             )
         )
     # and drop any version redirects to it
-    for key, val in list(versionRedirectMap.items()):
+    for key, val in versionRedirectMap.items():
         if val == info:
             del versionRedirectMap[key]
 
@@ -626,7 +645,7 @@ def EnsureDispatch(
 ):  # New fn, so we default the new demand feature to on!
     """Given a COM prog_id, return an object that is using makepy support, building if necessary"""
     disp = win32com.client.Dispatch(prog_id)
-    if not disp.__dict__.get("CLSID"):  # Eeek - no makepy support - try and build it.
+    if not hasattr(disp, "CLSID"):  # Eeek - no makepy support - try and build it.
         try:
             ti = disp._oleobj_.GetTypeInfo()
             disp_clsid = ti.GetTypeAttr()[0]
@@ -660,7 +679,7 @@ def AddModuleToCache(
 
     def SetTypelibForAllClsids(dict):
         nonlocal dict_modified
-        for clsid, cls in dict.items():
+        for clsid in dict:
             if clsidToTypelib.get(clsid) != info:
                 clsidToTypelib[clsid] = info
                 dict_modified = True
@@ -685,7 +704,7 @@ def GetGeneratedInfos():
         zip_file = win32com.__gen_path__[: zip_pos + 4]
         zip_path = win32com.__gen_path__[zip_pos + 5 :].replace("\\", "/")
         zf = zipfile.ZipFile(zip_file)
-        infos = {}
+        infos = set()
         for n in zf.namelist():
             if not n.startswith(zip_path):
                 continue
@@ -701,9 +720,9 @@ def GetGeneratedInfos():
             except pywintypes.com_error:
                 # invalid IID
                 continue
-            infos[(iid, lcid, major, minor)] = 1
+            infos.add((iid, lcid, major, minor))
         zf.close()
-        return list(infos.keys())
+        return list(infos)
     else:
         # on the file system
         files = glob.glob(win32com.__gen_path__ + "\\*")
@@ -730,7 +749,8 @@ def GetGeneratedInfos():
 def _GetModule(fname):
     """Given the name of a module in the gen_py directory, import and return it."""
     mod_name = "win32com.gen_py.%s" % fname
-    mod = __import__(mod_name)
+    with ModuleMutex(fname):
+        __import__(mod_name)
     return sys.modules[mod_name]
 
 
@@ -760,10 +780,8 @@ def Rebuild(verbose=1):
 def _Dump():
     print("Cache is in directory", win32com.__gen_path__)
     # Build a unique dir
-    d = {}
-    for clsid, (typelibCLSID, lcid, major, minor) in clsidToTypelib.items():
-        d[typelibCLSID, lcid, major, minor] = None
-    for typelibCLSID, lcid, major, minor in d.keys():
+    d = set(clsidToTypelib.values())
+    for typelibCLSID, lcid, major, minor in d:
         mod = GetModuleForTypelib(typelibCLSID, lcid, major, minor)
         print(f"{mod.__doc__} - {typelibCLSID}")