py2docfx 0.1.15.dev2025501__py3-none-any.whl → 0.1.15.dev2038808__py3-none-any.whl

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

@@ -1,277 +0,0 @@
-import commctrl
-import pythoncom
-import win32api
-import win32con
-import win32ui
-from pywin.mfc import dialog
-
-
-class TLBrowserException(Exception):
-    "TypeLib browser internal error"
-
-
-error = TLBrowserException  # Re-exported alias
-
-FRAMEDLG_STD = win32con.WS_CAPTION | win32con.WS_SYSMENU
-SS_STD = win32con.WS_CHILD | win32con.WS_VISIBLE
-BS_STD = SS_STD | win32con.WS_TABSTOP
-ES_STD = BS_STD | win32con.WS_BORDER
-LBS_STD = (
-    ES_STD | win32con.LBS_NOTIFY | win32con.LBS_NOINTEGRALHEIGHT | win32con.WS_VSCROLL
-)
-CBS_STD = ES_STD | win32con.CBS_NOINTEGRALHEIGHT | win32con.WS_VSCROLL
-
-typekindmap = {
-    pythoncom.TKIND_ENUM: "Enumeration",
-    pythoncom.TKIND_RECORD: "Record",
-    pythoncom.TKIND_MODULE: "Module",
-    pythoncom.TKIND_INTERFACE: "Interface",
-    pythoncom.TKIND_DISPATCH: "Dispatch",
-    pythoncom.TKIND_COCLASS: "CoClass",
-    pythoncom.TKIND_ALIAS: "Alias",
-    pythoncom.TKIND_UNION: "Union",
-}
-
-TypeBrowseDialog_Parent = dialog.Dialog
-
-
-class TypeBrowseDialog(TypeBrowseDialog_Parent):
-    "Browse a type library"
-
-    IDC_TYPELIST = 1000
-    IDC_MEMBERLIST = 1001
-    IDC_PARAMLIST = 1002
-    IDC_LISTVIEW = 1003
-
-    def __init__(self, typefile=None):
-        TypeBrowseDialog_Parent.__init__(self, self.GetTemplate())
-        try:
-            if typefile:
-                self.tlb = pythoncom.LoadTypeLib(typefile)
-            else:
-                self.tlb = None
-        except pythoncom.ole_error:
-            self.MessageBox("The file does not contain type information")
-            self.tlb = None
-        self.HookCommand(self.CmdTypeListbox, self.IDC_TYPELIST)
-        self.HookCommand(self.CmdMemberListbox, self.IDC_MEMBERLIST)
-
-    def OnAttachedObjectDeath(self):
-        self.tlb = None
-        self.typeinfo = None
-        self.attr = None
-        return TypeBrowseDialog_Parent.OnAttachedObjectDeath(self)
-
-    def _SetupMenu(self):
-        menu = win32ui.CreateMenu()
-        flags = win32con.MF_STRING | win32con.MF_ENABLED
-        menu.AppendMenu(flags, win32ui.ID_FILE_OPEN, "&Open...")
-        menu.AppendMenu(flags, win32con.IDCANCEL, "&Close")
-        mainMenu = win32ui.CreateMenu()
-        mainMenu.AppendMenu(flags | win32con.MF_POPUP, menu.GetHandle(), "&File")
-        self.SetMenu(mainMenu)
-        self.HookCommand(self.OnFileOpen, win32ui.ID_FILE_OPEN)
-
-    def OnFileOpen(self, id, code):
-        openFlags = win32con.OFN_OVERWRITEPROMPT | win32con.OFN_FILEMUSTEXIST
-        fspec = "Type Libraries (*.tlb, *.olb)|*.tlb;*.olb|OCX Files (*.ocx)|*.ocx|DLL's (*.dll)|*.dll|All Files (*.*)|*.*||"
-        dlg = win32ui.CreateFileDialog(1, None, None, openFlags, fspec)
-        if dlg.DoModal() == win32con.IDOK:
-            try:
-                self.tlb = pythoncom.LoadTypeLib(dlg.GetPathName())
-            except pythoncom.ole_error:
-                self.MessageBox("The file does not contain type information")
-                self.tlb = None
-            self._SetupTLB()
-
-    def OnInitDialog(self):
-        self._SetupMenu()
-        self.typelb = self.GetDlgItem(self.IDC_TYPELIST)
-        self.memberlb = self.GetDlgItem(self.IDC_MEMBERLIST)
-        self.paramlb = self.GetDlgItem(self.IDC_PARAMLIST)
-        self.listview = self.GetDlgItem(self.IDC_LISTVIEW)
-
-        # Setup the listview columns
-        itemDetails = (commctrl.LVCFMT_LEFT, 100, "Item", 0)
-        self.listview.InsertColumn(0, itemDetails)
-        itemDetails = (commctrl.LVCFMT_LEFT, 1024, "Details", 0)
-        self.listview.InsertColumn(1, itemDetails)
-
-        if self.tlb is None:
-            self.OnFileOpen(None, None)
-        else:
-            self._SetupTLB()
-        return TypeBrowseDialog_Parent.OnInitDialog(self)
-
-    def _SetupTLB(self):
-        self.typelb.ResetContent()
-        self.memberlb.ResetContent()
-        self.paramlb.ResetContent()
-        self.typeinfo = None
-        self.attr = None
-        if self.tlb is None:
-            return
-        n = self.tlb.GetTypeInfoCount()
-        for i in range(n):
-            self.typelb.AddString(self.tlb.GetDocumentation(i)[0])
-
-    def _SetListviewTextItems(self, items):
-        self.listview.DeleteAllItems()
-        index = -1
-        for item in items:
-            index = self.listview.InsertItem(index + 1, item[0])
-            data = item[1]
-            if data is None:
-                data = ""
-            self.listview.SetItemText(index, 1, data)
-
-    def SetupAllInfoTypes(self):
-        infos = self._GetMainInfoTypes() + self._GetMethodInfoTypes()
-        self._SetListviewTextItems(infos)
-
-    def _GetMainInfoTypes(self):
-        pos = self.typelb.GetCurSel()
-        if pos < 0:
-            return []
-        docinfo = self.tlb.GetDocumentation(pos)
-        infos = [("GUID", str(self.attr[0]))]
-        infos.append(("Help File", docinfo[3]))
-        infos.append(("Help Context", str(docinfo[2])))
-        try:
-            infos.append(("Type Kind", typekindmap[self.tlb.GetTypeInfoType(pos)]))
-        except:
-            pass
-
-        info = self.tlb.GetTypeInfo(pos)
-        attr = info.GetTypeAttr()
-        infos.append(("Attributes", str(attr)))
-
-        for j in range(attr[8]):
-            flags = info.GetImplTypeFlags(j)
-            refInfo = info.GetRefTypeInfo(info.GetRefTypeOfImplType(j))
-            doc = refInfo.GetDocumentation(-1)
-            attr = refInfo.GetTypeAttr()
-            typeKind = attr[5]
-            typeFlags = attr[11]
-
-            desc = doc[0]
-            desc += ", Flags=0x{:x}, typeKind=0x{:x}, typeFlags=0x{:x}".format(
-                flags, typeKind, typeFlags
-            )
-            if flags & pythoncom.IMPLTYPEFLAG_FSOURCE:
-                desc += "(Source)"
-            infos.append(("Implements", desc))
-
-        return infos
-
-    def _GetMethodInfoTypes(self):
-        pos = self.memberlb.GetCurSel()
-        if pos < 0:
-            return []
-
-        realPos, isMethod = self._GetRealMemberPos(pos)
-        ret = []
-        if isMethod:
-            funcDesc = self.typeinfo.GetFuncDesc(realPos)
-            id = funcDesc[0]
-            ret.append(("Func Desc", str(funcDesc)))
-        else:
-            id = self.typeinfo.GetVarDesc(realPos)[0]
-
-        docinfo = self.typeinfo.GetDocumentation(id)
-        ret.append(("Help String", docinfo[1]))
-        ret.append(("Help Context", str(docinfo[2])))
-        return ret
-
-    def CmdTypeListbox(self, id, code):
-        if code == win32con.LBN_SELCHANGE:
-            pos = self.typelb.GetCurSel()
-            if pos >= 0:
-                self.memberlb.ResetContent()
-                self.typeinfo = self.tlb.GetTypeInfo(pos)
-                self.attr = self.typeinfo.GetTypeAttr()
-                for i in range(self.attr[7]):
-                    id = self.typeinfo.GetVarDesc(i)[0]
-                    self.memberlb.AddString(self.typeinfo.GetNames(id)[0])
-                for i in range(self.attr[6]):
-                    id = self.typeinfo.GetFuncDesc(i)[0]
-                    self.memberlb.AddString(self.typeinfo.GetNames(id)[0])
-                self.SetupAllInfoTypes()
-            return 1
-
-    def _GetRealMemberPos(self, pos):
-        pos = self.memberlb.GetCurSel()
-        if pos >= self.attr[7]:
-            return pos - self.attr[7], 1
-        elif pos >= 0:
-            return pos, 0
-        else:
-            raise error("The position is not valid")
-
-    def CmdMemberListbox(self, id, code):
-        if code == win32con.LBN_SELCHANGE:
-            self.paramlb.ResetContent()
-            pos = self.memberlb.GetCurSel()
-            realPos, isMethod = self._GetRealMemberPos(pos)
-            if isMethod:
-                id = self.typeinfo.GetFuncDesc(realPos)[0]
-                names = self.typeinfo.GetNames(id)
-                for i in range(len(names)):
-                    if i > 0:
-                        self.paramlb.AddString(names[i])
-            self.SetupAllInfoTypes()
-            return 1
-
-    def GetTemplate(self):
-        "Return the template used to create this dialog"
-
-        w = 272  # Dialog width
-        h = 192  # Dialog height
-        style = (
-            FRAMEDLG_STD
-            | win32con.WS_VISIBLE
-            | win32con.DS_SETFONT
-            | win32con.WS_MINIMIZEBOX
-        )
-        template = [
-            ["Type Library Browser", (0, 0, w, h), style, None, (8, "Helv")],
-        ]
-        template.append([130, "&Type", -1, (10, 10, 62, 9), SS_STD | win32con.SS_LEFT])
-        template.append([131, None, self.IDC_TYPELIST, (10, 20, 80, 80), LBS_STD])
-        template.append(
-            [130, "&Members", -1, (100, 10, 62, 9), SS_STD | win32con.SS_LEFT]
-        )
-        template.append([131, None, self.IDC_MEMBERLIST, (100, 20, 80, 80), LBS_STD])
-        template.append(
-            [130, "&Parameters", -1, (190, 10, 62, 9), SS_STD | win32con.SS_LEFT]
-        )
-        template.append([131, None, self.IDC_PARAMLIST, (190, 20, 75, 80), LBS_STD])
-
-        lvStyle = (
-            SS_STD
-            | commctrl.LVS_REPORT
-            | commctrl.LVS_AUTOARRANGE
-            | commctrl.LVS_ALIGNLEFT
-            | win32con.WS_BORDER
-            | win32con.WS_TABSTOP
-        )
-        template.append(
-            ["SysListView32", "", self.IDC_LISTVIEW, (10, 110, 255, 65), lvStyle]
-        )
-
-        return template
-
-
-if __name__ == "__main__":
-    import sys
-
-    fname = None
-    try:
-        fname = sys.argv[1]
-    except:
-        pass
-    dlg = TypeBrowseDialog(fname)
-    if win32api.GetConsoleTitle():  # empty string w/o console
-        dlg.DoModal()
-    else:
-        dlg.CreateWindow(win32ui.GetMainFrame())

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

@@ -1,103 +0,0 @@
-"""General client side utilities.
-
-This module contains utility functions, used primarily by advanced COM
-programmers, or other COM modules.
-"""
-
-import pythoncom
-from win32com.client import _get_good_object_
-
-PyIDispatchType = pythoncom.TypeIIDs[pythoncom.IID_IDispatch]
-
-
-def WrapEnum(ob, resultCLSID=None):
-    """Wrap an object in a VARIANT enumerator.
-
-    All VT_DISPATCHs returned by the enumerator are converted to wrapper objects
-    (which may be either a class instance, or a dynamic.Dispatch type object).
-
-    """
-    if not isinstance(ob, pythoncom.TypeIIDs[pythoncom.IID_IEnumVARIANT]):
-        ob = ob.QueryInterface(pythoncom.IID_IEnumVARIANT)
-    return EnumVARIANT(ob, resultCLSID)
-
-
-class Enumerator:
-    """A class that provides indexed access into an Enumerator
-
-    By wrapping a PyIEnum* object in this class, you can perform
-    natural looping and indexing into the Enumerator.
-
-    Looping is very efficient, but it should be noted that although random
-    access is supported, the underlying object is still an enumerator, so
-    this will force many reset-and-seek operations to find the requested index.
-
-    """
-
-    def __init__(self, enum):
-        self._oleobj_ = enum  # a PyIEnumVARIANT
-        self.index = -1
-
-    def __getitem__(self, index):
-        return self.__GetIndex(index)
-
-    def __call__(self, index):
-        return self.__GetIndex(index)
-
-    def __GetIndex(self, index):
-        if not isinstance(index, int):
-            raise TypeError("Only integer indexes are supported for enumerators")
-        # NOTE
-        # In this context, self.index is users purely as a flag to say
-        # "am I still in sequence".  The user may call Next() or Reset() if they
-        # so choose, in which case self.index will not be correct (although we
-        # still want to stay in sequence)
-        if index != self.index + 1:
-            # Index requested out of sequence.
-            self._oleobj_.Reset()
-            if index:
-                self._oleobj_.Skip(
-                    index
-                )  # if asked for item 1, must skip 1, Python always zero based.
-        self.index = index
-        result = self._oleobj_.Next(1)
-        if len(result):
-            return self._make_retval_(result[0])
-        raise IndexError("list index out of range")
-
-    def Next(self, count=1):
-        ret = self._oleobj_.Next(count)
-        realRets = []
-        for r in ret:
-            realRets.append(self._make_retval_(r))
-        return tuple(realRets)  # Convert back to tuple.
-
-    def Reset(self):
-        return self._oleobj_.Reset()
-
-    def Clone(self):
-        return self.__class__(self._oleobj_.Clone(), self.resultCLSID)
-
-    def _make_retval_(self, result):
-        return result
-
-
-class EnumVARIANT(Enumerator):
-    def __init__(self, enum, resultCLSID=None):
-        self.resultCLSID = resultCLSID
-        Enumerator.__init__(self, enum)
-
-    def _make_retval_(self, result):
-        return _get_good_object_(result, resultCLSID=self.resultCLSID)
-
-
-class Iterator:
-    def __init__(self, enum, resultCLSID=None):
-        self.resultCLSID = resultCLSID
-        self._iter_ = iter(enum.QueryInterface(pythoncom.IID_IEnumVARIANT))
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return _get_good_object_(next(self._iter_), resultCLSID=self.resultCLSID)

py2docfx/venv/venv1/Lib/site-packages/win32com/demos/connect.py

@@ -1,96 +0,0 @@
-# Implements _both_ a connectable client, and a connectable server.
-#
-# Note that we cheat just a little - the Server in this demo is not created
-# via Normal COM - this means we can avoid registering the server.
-# However, the server _is_ accessed as a COM object - just the creation
-# is cheated on - so this is still working as a fully-fledged server.
-
-import pythoncom
-import win32com.server.connect
-import win32com.server.util
-
-# This is the IID of the Events interface both Client and Server support.
-IID_IConnectDemoEvents = pythoncom.MakeIID("{A4988850-49C3-11d0-AE5D-52342E000000}")
-
-# The server which implements
-# Create a connectable class, that has a single public method
-# 'DoIt', which echos to a single sink 'DoneIt'
-
-
-class ConnectableServer(win32com.server.connect.ConnectableServer):
-    _public_methods_ = [
-        "DoIt"
-    ] + win32com.server.connect.ConnectableServer._public_methods_
-    _connect_interfaces_ = [IID_IConnectDemoEvents]
-
-    # The single public method that the client can call on us
-    # (ie, as a normal COM server, this exposes just this single method.
-    def DoIt(self, arg):
-        # Simply broadcast a notification.
-        self._BroadcastNotify(self.NotifyDoneIt, (arg,))
-
-    def NotifyDoneIt(self, interface, arg):
-        interface.Invoke(1000, 0, pythoncom.DISPATCH_METHOD, 1, arg)
-
-
-# Here is the client side of the connection world.
-# Define a COM object which implements the methods defined by the
-# IConnectDemoEvents interface.
-class ConnectableClient:
-    # This is another cheat - I _know_ the server defines the "DoneIt" event
-    # as DISPID==1000 - I also know from the implementation details of COM
-    # that the first method in _public_methods_ gets 1000.
-    # Normally some explicit DISPID->Method mapping is required.
-    _public_methods_ = ["OnDoneIt"]
-
-    def __init__(self):
-        self.last_event_arg = None
-
-    # A client must implement QI, and respond to a query for the Event interface.
-    # In addition, it must provide a COM object (which server.util.wrap) does.
-    def _query_interface_(self, iid):
-        # Note that this seems like a necessary hack.  I am responding to IID_IConnectDemoEvents
-        # but only creating an IDispatch gateway object.
-        if iid == IID_IConnectDemoEvents:
-            return win32com.server.util.wrap(self)
-
-    # And here is our event method which gets called.
-    def OnDoneIt(self, arg):
-        self.last_event_arg = arg
-
-
-def CheckEvent(server, client, val, verbose):
-    client.last_event_arg = None
-    server.DoIt(val)
-    if client.last_event_arg != val:
-        raise RuntimeError(f"Sent {val!r}, but got back {client.last_event_arg!r}")
-    if verbose:
-        print("Sent and received %r" % val)
-
-
-# A simple test script for all this.
-# In the real world, it is likely that the code controlling the server
-# will be in the same class as that getting the notifications.
-def test(verbose=0):
-    import win32com.client.connect
-    import win32com.client.dynamic
-    import win32com.server.policy
-
-    server = win32com.client.dynamic.Dispatch(
-        win32com.server.util.wrap(ConnectableServer())
-    )
-    connection = win32com.client.connect.SimpleConnection()
-    client = ConnectableClient()
-    connection.Connect(server, client, IID_IConnectDemoEvents)
-    CheckEvent(server, client, "Hello", verbose)
-    CheckEvent(server, client, b"Here is a null>\x00<", verbose)
-    CheckEvent(server, client, "Here is a null>\x00<", verbose)
-    val = "test-\xe0\xf2"  # 2 extended characters.
-    CheckEvent(server, client, val, verbose)
-    if verbose:
-        print("Everything seemed to work!")
-    # Aggressive memory leak checking (ie, do nothing!) :-)  All should cleanup OK???
-
-
-if __name__ == "__main__":
-    test(1)

py2docfx/venv/venv1/Lib/site-packages/win32com/demos/dump_clipboard.py

@@ -1,74 +0,0 @@
-import pythoncom
-import win32con
-
-formats = """CF_TEXT CF_BITMAP CF_METAFILEPICT CF_SYLK CF_DIF CF_TIFF
-            CF_OEMTEXT CF_DIB CF_PALETTE CF_PENDATA CF_RIFF CF_WAVE
-            CF_UNICODETEXT CF_ENHMETAFILE CF_HDROP CF_LOCALE CF_MAX
-            CF_OWNERDISPLAY CF_DSPTEXT CF_DSPBITMAP CF_DSPMETAFILEPICT
-            CF_DSPENHMETAFILE""".split()
-format_name_map = {}
-for f in formats:
-    val = getattr(win32con, f)
-    format_name_map[val] = f
-
-tymeds = [attr for attr in pythoncom.__dict__ if attr.startswith("TYMED_")]
-
-
-def DumpClipboard():
-    do = pythoncom.OleGetClipboard()
-    print("Dumping all clipboard formats...")
-    for fe in do.EnumFormatEtc():
-        fmt, td, aspect, index, tymed = fe
-        tymeds_this = [
-            getattr(pythoncom, t) for t in tymeds if tymed & getattr(pythoncom, t)
-        ]
-        print("Clipboard format", format_name_map.get(fmt, str(fmt)))
-        for t_this in tymeds_this:
-            # As we are enumerating there should be no need to call
-            # QueryGetData, but we do anyway!
-            fetc_query = fmt, td, aspect, index, t_this
-            try:
-                do.QueryGetData(fetc_query)
-            except pythoncom.com_error:
-                print("Eeek - QGD indicated failure for tymed", t_this)
-            # now actually get it.
-            try:
-                medium = do.GetData(fetc_query)
-            except pythoncom.com_error as exc:
-                print("Failed to get the clipboard data:", exc)
-                continue
-            if medium.tymed == pythoncom.TYMED_GDI:
-                data = "GDI handle %d" % medium.data
-            elif medium.tymed == pythoncom.TYMED_MFPICT:
-                data = "METAFILE handle %d" % medium.data
-            elif medium.tymed == pythoncom.TYMED_ENHMF:
-                data = "ENHMETAFILE handle %d" % medium.data
-            elif medium.tymed == pythoncom.TYMED_HGLOBAL:
-                data = "%d bytes via HGLOBAL" % len(medium.data)
-            elif medium.tymed == pythoncom.TYMED_FILE:
-                data = "filename '%s'" % data
-            elif medium.tymed == pythoncom.TYMED_ISTREAM:
-                stream = medium.data
-                stream.Seek(0, 0)
-                bytes = 0
-                while 1:
-                    chunk = stream.Read(4096)
-                    if not chunk:
-                        break
-                    bytes += len(chunk)
-                data = "%d bytes via IStream" % bytes
-            elif medium.tymed == pythoncom.TYMED_ISTORAGE:
-                data = "a IStorage"
-            else:
-                data = "*** unknown tymed!"
-            print(" -> got", data)
-    do = None
-
-
-if __name__ == "__main__":
-    DumpClipboard()
-    if pythoncom._GetInterfaceCount() + pythoncom._GetGatewayCount():
-        print(
-            "XXX - Leaving with %d/%d COM objects alive"
-            % (pythoncom._GetInterfaceCount(), pythoncom._GetGatewayCount())
-        )

py2docfx/venv/venv1/Lib/site-packages/win32com/demos/eventsApartmentThreaded.py

@@ -1,98 +0,0 @@
-# A sample originally provided by Richard Bell, and modified by Mark Hammond.
-
-# This sample demonstrates how to use COM events in an aparment-threaded
-# world.  In this world, COM itself ensures that all calls to and events
-# from an object happen on the same thread that created the object, even
-# if they originated from different threads.  For this cross-thread
-# marshalling to work, this main thread *must* run a "message-loop" (ie,
-# a loop fetching and dispatching Windows messages).  Without such message
-# processing, dead-locks can occur.
-
-# See also eventsFreeThreaded.py for how to do this in a free-threaded
-# world where these marshalling considerations do not exist.
-
-# NOTE: This example uses Internet Explorer, but it should not be considerd
-# a "best-practices" for writing against IE events, but for working with
-# events in general. For example:
-# * The first OnDocumentComplete event is not a reliable indicator that the
-#   URL has completed loading
-# * As we are demonstrating the most efficient way of handling events, when
-#   running this sample you will see an IE Windows briefly appear, but
-#   vanish without ever being repainted.
-
-import time
-
-# sys.coinit_flags not set, so pythoncom initializes apartment-threaded.
-import pythoncom
-import win32api
-import win32com.client
-import win32event
-
-
-class ExplorerEvents:
-    def __init__(self):
-        self.event = win32event.CreateEvent(None, 0, 0, None)
-
-    def OnDocumentComplete(self, pDisp=pythoncom.Empty, URL=pythoncom.Empty):
-        thread = win32api.GetCurrentThreadId()
-        print("OnDocumentComplete event processed on thread %d" % thread)
-        # Set the event our main thread is waiting on.
-        win32event.SetEvent(self.event)
-
-    def OnQuit(self):
-        thread = win32api.GetCurrentThreadId()
-        print("OnQuit event processed on thread %d" % thread)
-        win32event.SetEvent(self.event)
-
-
-def WaitWhileProcessingMessages(event, timeout=2):
-    start = time.perf_counter()
-    while True:
-        # Wake 4 times a second - we can't just specify the
-        # full timeout here, as then it would reset for every
-        # message we process.
-        rc = win32event.MsgWaitForMultipleObjects(
-            (event,), 0, 250, win32event.QS_ALLEVENTS
-        )
-        if rc == win32event.WAIT_OBJECT_0:
-            # event signalled - stop now!
-            return True
-        if (time.perf_counter() - start) > timeout:
-            # Timeout expired.
-            return False
-        # must be a message.
-        pythoncom.PumpWaitingMessages()
-
-
-def TestExplorerEvents():
-    iexplore = win32com.client.DispatchWithEvents(
-        "InternetExplorer.Application", ExplorerEvents
-    )
-
-    thread = win32api.GetCurrentThreadId()
-    print("TestExplorerEvents created IE object on thread %d" % thread)
-
-    iexplore.Visible = 1
-    try:
-        iexplore.Navigate(win32api.GetFullPathName("..\\readme.html"))
-    except pythoncom.com_error as details:
-        print("Warning - could not open the test HTML file", details)
-
-    # Wait for the event to be signalled while pumping messages.
-    if not WaitWhileProcessingMessages(iexplore.event):
-        print("Document load event FAILED to fire!!!")
-
-    iexplore.Quit()
-    #
-    # Give IE a chance to shutdown, else it can get upset on fast machines.
-    # Note, Quit generates events.  Although this test does NOT catch them
-    # it is NECESSARY to pump messages here instead of a sleep so that the Quit
-    # happens properly!
-    if not WaitWhileProcessingMessages(iexplore.event):
-        print("OnQuit event FAILED to fire!!!")
-
-    iexplore = None
-
-
-if __name__ == "__main__":
-    TestExplorerEvents()