py2docfx 0.1.15rc2025477__py3-none-any.whl → 0.1.16.dev2051338__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/win32com/test/testMSOffice.py

@@ -1,184 +0,0 @@
-# Test MSOffice
-#
-# Main purpose of test is to ensure that Dynamic COM objects
-# work as expected.
-
-# Assumes Word and Excel installed on your machine.
-
-import traceback
-
-import pythoncom
-import win32api
-import win32com
-import win32com.client.dynamic
-from win32com.client import gencache
-from win32com.test.util import CheckClean
-
-
-# Test a few of the MSOffice components.
-def TestWord():
-    try:
-        # Office 97 - _totally_ different object model!
-        word7 = win32com.client.Dispatch("Word.Basic")
-        # Check if any property needed by TestWord7 is not None
-        if word7.FileNew:
-            print("Starting Word 7 for dynamic test")
-            TestWord7(word7)
-        else:
-            # NOTE - using "client.Dispatch" would return an msword8.py instance!
-            print("Starting Word 8 for dynamic test")
-            word = win32com.client.dynamic.Dispatch("Word.Application")
-            TestWord8(word)
-
-            word = None
-            # Now we will test Dispatch without the new "lazy" capabilities
-            print("Starting Word 8 for non-lazy dynamic test")
-            dispatch = win32com.client.dynamic._GetGoodDispatch("Word.Application")
-            typeinfo = dispatch.GetTypeInfo()
-            attr = typeinfo.GetTypeAttr()
-            olerepr = win32com.client.build.DispatchItem(typeinfo, attr, None, 0)
-            word = win32com.client.dynamic.CDispatch(dispatch, olerepr)
-            dispatch = typeinfo = attr = olerepr = None
-            TestWord8(word)
-    except Exception as e:
-        print("Word dynamic tests failed", e)
-        traceback.print_exc()
-
-    print("Starting MSWord for generated test")
-    try:
-        from win32com.client import gencache
-
-        word = gencache.EnsureDispatch("Word.Application.8")
-        TestWord8(word)
-    except Exception as e:
-        print("Word generated tests failed", e)
-        traceback.print_exc()
-
-
-def TestWord7(word):
-    word.FileNew()
-    # If not shown, show the app.
-    if not word.AppShow():
-        word._proc_("AppShow")
-
-    for i in range(12):
-        word.FormatFont(Color=i + 1, Points=i + 12)
-        word.Insert("Hello from Python %d\n" % i)
-
-    word.FileClose(2)
-
-
-def TestWord8(word):
-    word.Visible = 1
-    doc = word.Documents.Add()
-    wrange = doc.Range()
-    for i in range(10):
-        wrange.InsertAfter(f"Hello from Python {i + 1}\n")
-    paras = doc.Paragraphs
-    if int(word.Version.split(".")[0]) >= 16:
-        # With Word 16 / Word 2019
-        for i, p in enumerate(paras):
-            p.Range.Font.ColorIndex = i + 1
-            p.Range.Font.Size = 12 + (4 * i)
-    else:
-        # NOTE: Iterating on paras doesn't seem to work - no error, just doesn't work
-        # for para in paras:
-        #     para().Font...
-        for i in range(len(paras)):
-            p = paras(i + 1)
-            p.Font.ColorIndex = i + 1
-            p.Font.Size = 12 + (4 * i)
-    doc.Close(SaveChanges=False)
-    word.Quit()
-    win32api.Sleep(1000)  # Wait for word to close, else we may get OA error.
-
-
-def TestWord8OldStyle():
-    try:
-        import win32com.test.Generated4Test.msword8
-    except ImportError:
-        print("Can not do old style test")
-
-
-def TextExcel(xl):
-    xl.Visible = 0
-    assert not xl.Visible, "Visible property is true."
-    xl.Visible = 1
-    assert xl.Visible, "Visible property not true."
-
-    xl.Workbooks.Add()
-
-    xl.Range("A1:C1").Value = (1, 2, 3)
-    xl.Range("A2:C2").Value = ("x", "y", "z")
-    xl.Range("A3:C3").Value = ("3", "2", "1")
-
-    for i in range(20):
-        xl.Cells(i + 1, i + 1).Value = "Hi %d" % i
-
-    assert xl.Range("A1").Value == "Hi 0", "Single cell range failed"
-    assert xl.Range("A1:B1").Value == (
-        ("Hi 0", 2),
-    ), "flat-horizontal cell range failed"
-    assert xl.Range("A1:A2").Value == (
-        ("Hi 0",),
-        ("x",),
-    ), "flat-vertical cell range failed"
-    assert xl.Range("A1:C3").Value == (
-        ("Hi 0", 2, 3),
-        ("x", "Hi 1", "z"),
-        (3, 2, "Hi 2"),
-    ), "square cell range failed"
-
-    xl.Range("A1:C3").Value = ((3, 2, 1), ("x", "y", "z"), (1, 2, 3))
-
-    assert xl.Range("A1:C3").Value == (
-        (3, 2, 1),
-        ("x", "y", "z"),
-        (1, 2, 3),
-    ), "Range was not what I set it to!"
-
-    # test dates out with Excel
-    xl.Cells(5, 1).Value = "Excel time"
-    xl.Cells(5, 2).Formula = "=Now()"
-
-    import time
-
-    xl.Cells(6, 1).Value = "Python time"
-    xl.Cells(6, 2).Value = pythoncom.MakeTime(time.time())
-    xl.Cells(6, 2).NumberFormat = "d/mm/yy h:mm"
-    xl.Columns("A:B").EntireColumn.AutoFit()
-
-    xl.Workbooks(1).Close(0)
-    xl.Quit()
-
-
-def TestAll():
-    TestWord()
-
-    try:
-        print("Starting Excel for Dynamic test...")
-        xl = win32com.client.dynamic.Dispatch("Excel.Application")
-        TextExcel(xl)
-    except Exception as e:
-        worked = False
-        print("Excel tests failed", e)
-        traceback.print_exc()
-
-    try:
-        print("Starting Excel 8 for generated excel8.py test...")
-        mod = gencache.EnsureModule(
-            "{00020813-0000-0000-C000-000000000046}", 0, 1, 2, bForDemand=True
-        )
-        xl = win32com.client.Dispatch("Excel.Application")
-        TextExcel(xl)
-    except ImportError:
-        print("Could not import the generated Excel 97 wrapper")
-    except Exception as e:
-        print("Generated Excel tests failed", e)
-        traceback.print_exc()
-
-
-if __name__ == "__main__":
-    TestAll()
-    CheckClean()
-    pythoncom.CoUninitialize()

py2docfx/venv/venv1/Lib/site-packages/win32com/test/testMSOfficeEvents.py

@@ -1,138 +0,0 @@
-# OfficeEvents - test/demonstrate events with Word and Excel.
-import msvcrt
-import sys
-import threading
-import time
-import types
-
-import pythoncom
-from win32com.client import DispatchWithEvents
-
-stopEvent = threading.Event()
-
-
-def TestExcel():
-    class ExcelEvents:
-        def OnNewWorkbook(self, wb):
-            if not isinstance(wb, types.InstanceType):
-                raise RuntimeError(
-                    "The transformer doesn't appear to have translated this for us!"
-                )
-            self.seen_events["OnNewWorkbook"] = None
-
-        def OnWindowActivate(self, wb, wn):
-            if not isinstance(wb, types.InstanceType) or not isinstance(
-                wn, types.InstanceType
-            ):
-                raise RuntimeError(
-                    "The transformer doesn't appear to have translated this for us!"
-                )
-            self.seen_events["OnWindowActivate"] = None
-
-        def OnWindowDeactivate(self, wb, wn):
-            self.seen_events["OnWindowDeactivate"] = None
-
-        def OnSheetDeactivate(self, sh):
-            self.seen_events["OnSheetDeactivate"] = None
-
-        def OnSheetBeforeDoubleClick(self, Sh, Target, Cancel):
-            if Target.Column % 2 == 0:
-                print("You can double-click there...")
-            else:
-                print("You can not double-click there...")
-                # This function is a void, so the result ends up in
-                # the only ByRef - Cancel.
-                return 1
-
-    class WorkbookEvents:
-        def OnActivate(self):
-            print("workbook OnActivate")
-
-        def OnBeforeRightClick(self, Target, Cancel):
-            print("It's a Worksheet Event")
-
-    e = DispatchWithEvents("Excel.Application", ExcelEvents)
-    e.seen_events = {}
-    e.Visible = 1
-    book = e.Workbooks.Add()
-    book = DispatchWithEvents(book, WorkbookEvents)
-    print("Have book", book)
-    # sheet = e.Worksheets(1)
-    # sheet = DispatchWithEvents(sheet, WorksheetEvents)
-
-    print("Double-click in a few of the Excel cells...")
-    print("Press any key when finished with Excel, or wait 10 seconds...")
-    if not _WaitForFinish(e, 10):
-        e.Quit()
-    if not _CheckSeenEvents(e, ["OnNewWorkbook", "OnWindowActivate"]):
-        sys.exit(1)
-
-
-def TestWord():
-    class WordEvents:
-        def OnDocumentChange(self):
-            self.seen_events["OnDocumentChange"] = None
-
-        def OnWindowActivate(self, doc, wn):
-            self.seen_events["OnWindowActivate"] = None
-
-        def OnQuit(self):
-            self.seen_events["OnQuit"] = None
-            stopEvent.set()
-
-    w = DispatchWithEvents("Word.Application", WordEvents)
-    w.seen_events = {}
-    w.Visible = 1
-    w.Documents.Add()
-    print("Press any key when finished with Word, or wait 10 seconds...")
-    if not _WaitForFinish(w, 10):
-        w.Quit()
-    if not _CheckSeenEvents(w, ["OnDocumentChange", "OnWindowActivate"]):
-        sys.exit(1)
-
-
-def _WaitForFinish(ob, timeout):
-    end = time.time() + timeout
-    while 1:
-        if msvcrt.kbhit():
-            msvcrt.getch()
-            break
-        pythoncom.PumpWaitingMessages()
-        stopEvent.wait(0.2)
-        if stopEvent.isSet():
-            stopEvent.clear()
-            break
-        try:
-            if not ob.Visible:
-                # Gone invisible - we need to pretend we timed
-                # out, so the app is quit.
-                return 0
-        except pythoncom.com_error:
-            # Excel is busy (eg, editing the cell) - ignore
-            pass
-        if time.time() > end:
-            return 0
-    return 1
-
-
-def _CheckSeenEvents(o, events):
-    rc = 1
-    for e in events:
-        if e not in o.seen_events:
-            print("ERROR: Expected event did not trigger", e)
-            rc = 0
-    return rc
-
-
-def test():
-    import sys
-
-    if "noword" not in sys.argv[1:]:
-        TestWord()
-    if "noexcel" not in sys.argv[1:]:
-        TestExcel()
-    print("Word and Excel event tests passed.")
-
-
-if __name__ == "__main__":
-    test()

py2docfx/venv/venv1/Lib/site-packages/win32com/test/testMarshal.py

@@ -1,160 +0,0 @@
-"""Testing pasing object between multiple COM threads
-
-Uses standard COM marshalling to pass objects between threads.  Even
-though Python generally seems to work when you just pass COM objects
-between threads, it shouldn't.
-
-This shows the "correct" way to do it.
-
-It shows that although we create new threads to use the Python.Interpreter,
-COM marshalls back all calls to that object to the main Python thread,
-which must be running a message loop (as this sample does).
-
-When this test is run in "free threaded" mode (at this stage, you must
-manually mark the COM objects as "ThreadingModel=Free", or run from a
-service which has marked itself as free-threaded), then no marshalling
-is done, and the Python.Interpreter object start doing the "expected" thing
-- ie, it reports being on the same thread as its caller!
-
-Python.exe needs a good way to mark itself as FreeThreaded - at the moment
-this is a pain in the but!
-
-"""
-
-import threading
-import unittest
-
-import pythoncom
-import win32api
-import win32com.client
-import win32event
-
-from .testServers import InterpCase
-
-freeThreaded = 1
-
-
-class ThreadInterpCase(InterpCase):
-    def _testInterpInThread(self, stopEvent, interp):
-        try:
-            self._doTestInThread(interp)
-        finally:
-            win32event.SetEvent(stopEvent)
-
-    def _doTestInThread(self, interp):
-        pythoncom.CoInitialize()
-        myThread = win32api.GetCurrentThreadId()
-
-        if freeThreaded:
-            interp = pythoncom.CoGetInterfaceAndReleaseStream(
-                interp, pythoncom.IID_IDispatch
-            )
-            interp = win32com.client.Dispatch(interp)
-
-        interp.Exec("import win32api")
-        # print(f"The test thread id is {myThread}, Python.Interpreter's thread ID is {interp.Eval('win32api.GetCurrentThreadId()')}")
-        pythoncom.CoUninitialize()
-
-    def BeginThreadsSimpleMarshal(self, numThreads):
-        """Creates multiple threads using simple (but slower) marshalling.
-
-        Single interpreter object, but a new stream is created per thread.
-
-        Returns the handles the threads will set when complete.
-        """
-        interp = win32com.client.Dispatch("Python.Interpreter")
-        events = []
-        threads = []
-        for i in range(numThreads):
-            hEvent = win32event.CreateEvent(None, 0, 0, None)
-            events.append(hEvent)
-            interpStream = pythoncom.CoMarshalInterThreadInterfaceInStream(
-                pythoncom.IID_IDispatch, interp._oleobj_
-            )
-            t = threading.Thread(
-                target=self._testInterpInThread, args=(hEvent, interpStream)
-            )
-            t.setDaemon(1)  # so errors don't cause shutdown hang
-            t.start()
-            threads.append(t)
-        interp = None
-        return threads, events
-
-    #
-    # NOTE - this doesn't quite work - I'm not even sure it should, but Greg reckons
-    # you should be able to avoid the marshal per thread!
-    # I think that refers to CoMarshalInterface though...
-    def BeginThreadsFastMarshal(self, numThreads):
-        """Creates multiple threads using fast (but complex) marshalling.
-
-        The marshal stream is created once, and each thread uses the same stream
-
-        Returns the handles the threads will set when complete.
-        """
-        interp = win32com.client.Dispatch("Python.Interpreter")
-        if freeThreaded:
-            interp = pythoncom.CoMarshalInterThreadInterfaceInStream(
-                pythoncom.IID_IDispatch, interp._oleobj_
-            )
-        events = []
-        threads = []
-        for i in range(numThreads):
-            hEvent = win32event.CreateEvent(None, 0, 0, None)
-            t = threading.Thread(target=self._testInterpInThread, args=(hEvent, interp))
-            t.setDaemon(1)  # so errors don't cause shutdown hang
-            t.start()
-            events.append(hEvent)
-            threads.append(t)
-        return threads, events
-
-    def _DoTestMarshal(self, fn, bCoWait=0):
-        # print(f"The main thread is {win32api.GetCurrentThreadId()}")
-        threads, events = fn(2)
-        numFinished = 0
-        while 1:
-            try:
-                if bCoWait:
-                    rc = pythoncom.CoWaitForMultipleHandles(0, 2000, events)
-                else:
-                    # Specifying "bWaitAll" here will wait for messages *and* all events
-                    # (which is pretty useless)
-                    rc = win32event.MsgWaitForMultipleObjects(
-                        events, 0, 2000, win32event.QS_ALLINPUT
-                    )
-                if (
-                    rc >= win32event.WAIT_OBJECT_0
-                    and rc < win32event.WAIT_OBJECT_0 + len(events)
-                ):
-                    numFinished += 1
-                    if numFinished >= len(events):
-                        break
-                elif rc == win32event.WAIT_OBJECT_0 + len(events):  # a message
-                    # This is critical - whole apartment model demo will hang.
-                    pythoncom.PumpWaitingMessages()
-                else:  # Timeout
-                    print(
-                        "Waiting for thread to stop with interfaces=%d, gateways=%d"
-                        % (pythoncom._GetInterfaceCount(), pythoncom._GetGatewayCount())
-                    )
-            except KeyboardInterrupt:
-                break
-        for t in threads:
-            t.join(2)
-            self.assertFalse(t.is_alive(), "thread failed to stop!?")
-        threads = None  # threads hold references to args
-        # Seems to be a leak here I can't locate :(
-        # self.assertEqual(pythoncom._GetInterfaceCount(), 0)
-        # self.assertEqual(pythoncom._GetGatewayCount(), 0)
-
-    def testSimpleMarshal(self):
-        self._DoTestMarshal(self.BeginThreadsSimpleMarshal)
-
-    def testSimpleMarshalCoWait(self):
-        self._DoTestMarshal(self.BeginThreadsSimpleMarshal, 1)
-
-
-#    def testFastMarshal(self):
-#        self._DoTestMarshal(self.BeginThreadsFastMarshal)
-
-if __name__ == "__main__":
-    unittest.main("testMarshal")

py2docfx/venv/venv1/Lib/site-packages/win32com/test/testPersist.py

@@ -1,227 +0,0 @@
-import os
-
-import pythoncom
-import pywintypes
-import win32api
-import win32com
-import win32com.client
-import win32com.client.dynamic
-import win32com.server.util
-import win32timezone
-import win32ui
-from win32com import storagecon
-from win32com.axcontrol import axcontrol
-from win32com.test.util import CheckClean
-
-S_OK = 0
-
-now = win32timezone.now()
-
-
-class LockBytes:
-    _public_methods_ = [
-        "ReadAt",
-        "WriteAt",
-        "Flush",
-        "SetSize",
-        "LockRegion",
-        "UnlockRegion",
-        "Stat",
-    ]
-    _com_interfaces_ = [pythoncom.IID_ILockBytes]
-
-    def __init__(self, data=b""):
-        self.data = data
-        self.ctime = now
-        self.mtime = now
-        self.atime = now
-
-    def ReadAt(self, offset, cb):
-        print("ReadAt")
-        result = self.data[offset : offset + cb]
-        return result
-
-    def WriteAt(self, offset, data):
-        print("WriteAt", offset)
-        print("len", len(data))
-        print("data:")
-        # print(data)
-        if len(self.data) >= offset:
-            newdata = self.data[0:offset] + data
-        print(len(newdata))
-        if len(self.data) >= offset + len(data):
-            newdata += self.data[offset + len(data) :]
-        print(len(newdata))
-        self.data = newdata
-        return len(data)
-
-    def Flush(self, whatsthis=0):
-        print("Flush", whatsthis)
-        fname = os.path.join(win32api.GetTempPath(), "persist.doc")
-        open(fname, "wb").write(self.data)
-        return S_OK
-
-    def SetSize(self, size):
-        print("Set Size", size)
-        if size > len(self.data):
-            self.data += b"\000" * (size - len(self.data))
-        else:
-            self.data = self.data[0:size]
-        return S_OK
-
-    def LockRegion(self, offset, size, locktype):
-        print("LockRegion")
-
-    def UnlockRegion(self, offset, size, locktype):
-        print("UnlockRegion")
-
-    def Stat(self, statflag):
-        print("returning Stat", statflag)
-        return (
-            "PyMemBytes",
-            storagecon.STGTY_LOCKBYTES,
-            len(self.data),
-            self.mtime,
-            self.ctime,
-            self.atime,
-            storagecon.STGM_DIRECT | storagecon.STGM_READWRITE | storagecon.STGM_CREATE,
-            storagecon.STGM_SHARE_EXCLUSIVE,
-            "{00020905-0000-0000-C000-000000000046}",
-            0,  # statebits ?
-            0,
-        )
-
-
-class OleClientSite:
-    _public_methods_ = [
-        "SaveObject",
-        "GetMoniker",
-        "GetContainer",
-        "ShowObject",
-        "OnShowWindow",
-        "RequestNewObjectLayout",
-    ]
-    _com_interfaces_ = [axcontrol.IID_IOleClientSite]
-
-    def __init__(self, data=""):
-        self.IPersistStorage = None
-        self.IStorage = None
-
-    def SetIPersistStorage(self, IPersistStorage):
-        self.IPersistStorage = IPersistStorage
-
-    def SetIStorage(self, IStorage):
-        self.IStorage = IStorage
-
-    def SaveObject(self):
-        print("SaveObject")
-        if self.IPersistStorage is not None and self.IStorage is not None:
-            self.IPersistStorage.Save(self.IStorage, 1)
-            self.IStorage.Commit(0)
-        return S_OK
-
-    def GetMoniker(self, dwAssign, dwWhichMoniker):
-        print("GetMoniker", dwAssign, dwWhichMoniker)
-
-    def GetContainer(self):
-        print("GetContainer")
-
-    def ShowObject(self):
-        print("ShowObject")
-
-    def OnShowWindow(self, fShow):
-        print("ShowObject", fShow)
-
-    def RequestNewObjectLayout(self):
-        print("RequestNewObjectLayout")
-
-
-def test():
-    # create a LockBytes object and
-    # wrap it as a COM object
-    #       import win32com.server.dispatcher
-    lbcom = win32com.server.util.wrap(
-        LockBytes(), pythoncom.IID_ILockBytes
-    )  # , useDispatcher=win32com.server.dispatcher.DispatcherWin32trace)
-
-    # create a structured storage on the ILockBytes object
-    stcom = pythoncom.StgCreateDocfileOnILockBytes(
-        lbcom,
-        storagecon.STGM_DIRECT
-        | storagecon.STGM_CREATE
-        | storagecon.STGM_READWRITE
-        | storagecon.STGM_SHARE_EXCLUSIVE,
-        0,
-    )
-
-    # create our ClientSite
-    ocs = OleClientSite()
-    # wrap it as a COM object
-    ocscom = win32com.server.util.wrap(ocs, axcontrol.IID_IOleClientSite)
-
-    # create a Word OLE Document, connect it to our site and our storage
-    oocom = axcontrol.OleCreate(
-        "{00020906-0000-0000-C000-000000000046}",
-        axcontrol.IID_IOleObject,
-        0,
-        (0,),
-        ocscom,
-        stcom,
-    )
-
-    mf = win32ui.GetMainFrame()
-    hwnd = mf.GetSafeHwnd()
-
-    # Set the host and document name
-    # for unknown reason document name becomes hostname, and document name
-    # is not set, debugged it, but don't know where the problem is?
-    oocom.SetHostNames("OTPython", "This is Cool")
-
-    # activate the OLE document
-    oocom.DoVerb(-1, ocscom, 0, hwnd, mf.GetWindowRect())
-
-    # set the hostnames again
-    oocom.SetHostNames("OTPython2", "ThisisCool2")
-
-    # get IDispatch of Word
-    doc = win32com.client.Dispatch(oocom.QueryInterface(pythoncom.IID_IDispatch))
-
-    # get IPersistStorage of Word
-    dpcom = oocom.QueryInterface(pythoncom.IID_IPersistStorage)
-
-    # let our ClientSite know the interfaces
-    ocs.SetIPersistStorage(dpcom)
-    ocs.SetIStorage(stcom)
-
-    # use IDispatch to do the Office Word test
-    # pasted from TestOffice.py
-
-    wrange = doc.Range()
-    for i in range(10):
-        wrange.InsertAfter("Hello from Python %d\n" % i)
-    paras = doc.Paragraphs
-    for i in range(len(paras)):
-        paras[i]().Font.ColorIndex = i + 1
-        paras[i]().Font.Size = 12 + (4 * i)
-    # XXX - note that
-    # for para in paras:
-    #       para().Font...
-    # doesn't seem to work - no error, just doesn't work
-    # Should check if it works for VB!
-
-    dpcom.Save(stcom, 0)
-    dpcom.HandsOffStorage()
-    #       oocom.Close(axcontrol.OLECLOSE_NOSAVE) # or OLECLOSE_SAVEIFDIRTY, but it fails???
-
-    # Save the ILockBytes data to "persist2.doc"
-    lbcom.Flush()
-
-    # exiting Winword will automatically update the ILockBytes data
-    # and flush it to "%TEMP%\persist.doc"
-    doc.Application.Quit()
-
-
-if __name__ == "__main__":
-    test()
-    pythoncom.CoUninitialize()
-    CheckClean()