py2docfx 0.1.15.dev2025736__py3-none-any.whl → 0.1.15.dev2038852__py3-none-any.whl

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

@@ -1,139 +0,0 @@
-# testExplorer -
-
-import os
-import time
-
-import pythoncom
-import win32api
-import win32com.client.dynamic
-import win32con
-import win32gui
-import winerror
-from win32com.client import Dispatch
-from win32com.test.util import CheckClean
-
-bVisibleEventFired = 0
-
-# These are errors we might see when this is run in automation (eg, on github)
-# Not sure exactly what -2125463506 is, but google shows it's a common error
-# possibly related to how IE is configured WRT site permissions etc.
-HRESULTS_IN_AUTOMATION = [-2125463506, winerror.MK_E_UNAVAILABLE]
-
-
-class ExplorerEvents:
-    def OnVisible(self, visible):
-        global bVisibleEventFired
-        bVisibleEventFired = 1
-
-
-def TestExplorerEvents():
-    global bVisibleEventFired
-    try:
-        iexplore = win32com.client.DispatchWithEvents(
-            "InternetExplorer.Application", ExplorerEvents
-        )
-    except pythoncom.com_error as exc:
-        # In automation we see this error trying to connect to events
-        # It's a little surprising that the non-event tests seem to work, but
-        # whatever...
-        if exc.hresult not in HRESULTS_IN_AUTOMATION:
-            raise
-        print("IE events appear to not be available, so skipping this test")
-        return
-
-    iexplore.Visible = 1
-    assert bVisibleEventFired, "The IE event did not appear to fire!"
-    iexplore.Quit()
-    iexplore = None
-
-    bVisibleEventFired = 0
-    ie = win32com.client.Dispatch("InternetExplorer.Application")
-    ie_events = win32com.client.DispatchWithEvents(ie, ExplorerEvents)
-    ie.Visible = 1
-    assert bVisibleEventFired, "The IE event did not appear to fire!"
-    ie.Quit()
-    ie = None
-    print("IE Event tests worked.")
-
-
-def TestObjectFromWindow():
-    # Check we can use ObjectFromLresult to get the COM object from the
-    hwnd = win32gui.FindWindow("IEFrame", None)
-    # Thanks https://stackoverflow.com/a/10154498/18450412 for the child stack on IE8+
-    for child_class in (
-        "Frame Tab",
-        "TabWindowClass",
-        "Shell DocObject View",
-        "Internet Explorer_Server",
-    ):
-        hwnd = win32gui.FindWindowEx(hwnd, 0, child_class, None)
-    # Once you have an 'Internet Explorer_Server',
-    # you can send a message and use ObjectFromLresult to get it back.
-    msg = win32gui.RegisterWindowMessage("WM_HTML_GETOBJECT")
-    rc, result = win32gui.SendMessageTimeout(
-        hwnd, msg, 0, 0, win32con.SMTO_ABORTIFHUNG, 1000
-    )
-    ob = pythoncom.ObjectFromLresult(result, pythoncom.IID_IDispatch, 0)
-    doc = Dispatch(ob)
-    # just to prove it works, set the background color of the document.
-    for color in "red green blue orange white".split():
-        doc.bgColor = color
-        time.sleep(0.2)
-
-
-def TestExplorer(iexplore):
-    if not iexplore.Visible:
-        iexplore.Visible = -1
-    filename = os.path.join(os.path.dirname(__file__), "..\\readme.html")
-    iexplore.Navigate(win32api.GetFullPathName(filename))
-    win32api.Sleep(1000)
-    TestObjectFromWindow()
-    win32api.Sleep(3000)
-    try:
-        iexplore.Quit()
-    except (AttributeError, pythoncom.com_error):
-        # User got sick of waiting :)
-        pass
-
-
-def TestAll():
-    try:
-        try:
-            try:
-                iexplore = win32com.client.dynamic.Dispatch(
-                    "InternetExplorer.Application"
-                )
-            except pythoncom.com_error as exc:
-                if exc.hresult not in HRESULTS_IN_AUTOMATION:
-                    raise
-                print("IE appears to not be available, so skipping this test")
-                return
-
-            TestExplorer(iexplore)
-
-            win32api.Sleep(1000)
-            iexplore = None
-
-            # Test IE events.
-            TestExplorerEvents()
-            # Give IE a chance to shutdown, else it can get upset on fast machines.
-            time.sleep(2)
-
-            # Note that the TextExplorerEvents will force makepy - hence
-            # this gencache is really no longer needed.
-
-            from win32com.client import gencache
-
-            gencache.EnsureModule("{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}", 0, 1, 1)
-            iexplore = win32com.client.Dispatch("InternetExplorer.Application")
-            TestExplorer(iexplore)
-        except pythoncom.com_error as exc:
-            if exc.hresult != winerror.RPC_E_DISCONNECTED:  # user closed the app!
-                raise
-    finally:
-        iexplore = None
-
-
-if __name__ == "__main__":
-    TestAll()
-    CheckClean()

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

@@ -1,142 +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 _thread
-import traceback
-
-import pythoncom
-import win32api
-import win32com.client
-import win32event
-
-
-def TestInterp(interp):
-    assert interp.Eval("1+1") == 2, "The interpreter returned the wrong result."
-    try:
-        interp.Eval(1 + 1)
-        raise AssertionError("The interpreter did not raise an exception")
-    except pythoncom.com_error as details:
-        import winerror
-
-        assert (
-            details[0] == winerror.DISP_E_TYPEMISMATCH
-        ), "The interpreter exception was not winerror.DISP_E_TYPEMISMATCH."
-
-
-def TestInterpInThread(stopEvent, cookie):
-    try:
-        DoTestInterpInThread(cookie)
-    finally:
-        win32event.SetEvent(stopEvent)
-
-
-def CreateGIT():
-    return pythoncom.CoCreateInstance(
-        pythoncom.CLSID_StdGlobalInterfaceTable,
-        None,
-        pythoncom.CLSCTX_INPROC,
-        pythoncom.IID_IGlobalInterfaceTable,
-    )
-
-
-def DoTestInterpInThread(cookie):
-    try:
-        pythoncom.CoInitialize()
-        myThread = win32api.GetCurrentThreadId()
-        GIT = CreateGIT()
-
-        interp = GIT.GetInterfaceFromGlobal(cookie, pythoncom.IID_IDispatch)
-        interp = win32com.client.Dispatch(interp)
-
-        TestInterp(interp)
-        interp.Exec("import win32api")
-        print(
-            "The test thread id is %d, Python.Interpreter's thread ID is %d"
-            % (myThread, interp.Eval("win32api.GetCurrentThreadId()"))
-        )
-        interp = None
-        pythoncom.CoUninitialize()
-    except:
-        traceback.print_exc()
-
-
-def BeginThreadsSimpleMarshal(numThreads, cookie):
-    """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.
-    """
-    ret = []
-    for i in range(numThreads):
-        hEvent = win32event.CreateEvent(None, 0, 0, None)
-        _thread.start_new(TestInterpInThread, (hEvent, cookie))
-        ret.append(hEvent)
-    return ret
-
-
-def test(fn):
-    print("The main thread is %d" % (win32api.GetCurrentThreadId()))
-    GIT = CreateGIT()
-    interp = win32com.client.Dispatch("Python.Interpreter")
-    cookie = GIT.RegisterInterfaceInGlobal(interp._oleobj_, pythoncom.IID_IDispatch)
-
-    events = fn(4, cookie)
-    numFinished = 0
-    while 1:
-        try:
-            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
-    GIT.RevokeInterfaceFromGlobal(cookie)
-    del interp
-    del GIT
-
-
-if __name__ == "__main__":
-    test(BeginThreadsSimpleMarshal)
-    win32api.Sleep(500)
-    # Doing CoUninit here stop pythoncom.dll hanging when DLLMain shuts-down the process
-    pythoncom.CoUninitialize()
-    if pythoncom._GetInterfaceCount() != 0 or pythoncom._GetGatewayCount() != 0:
-        print(
-            "Done with interfaces=%d, gateways=%d"
-            % (pythoncom._GetInterfaceCount(), pythoncom._GetGatewayCount())
-        )
-    else:
-        print("Done.")

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

@@ -1,149 +0,0 @@
-# The purpose of this test is to ensure that the gateways objects
-# do the right thing WRT COM rules about object identity etc.
-
-# Also includes a basic test that we support inheritance correctly in
-# gateway interfaces.
-
-# For our test, we create an object of type IID_IPersistStorage
-# This interface derives from IPersist.
-# Therefore, QI's for IID_IDispatch, IID_IUnknown, IID_IPersist and
-# IID_IPersistStorage should all return the same gateway object.
-#
-# In addition, the interface should only need to declare itself as
-# using the IPersistStorage interface, and as the gateway derives
-# from IPersist, it should automatically be available without declaration.
-#
-# We also create an object of type IID_I??, and perform a QI for it.
-# We then jump through a number of hoops, ensuring that the objects
-# returned by the QIs follow all the rules.
-#
-# Here is Gregs summary of the rules:
-# 1) the set of supported interfaces is static and unchanging
-# 2) symmetric: if you QI an interface for that interface, it succeeds
-# 3) reflexive: if you QI against A for B, the new pointer must succeed
-#   for a QI for A
-# 4) transitive: if you QI for B, then QI that for C, then QI'ing A for C
-#   must succeed
-#
-#
-# Note that 1) Requires cooperation of the Python programmer.  The rule to keep is:
-# "whenever you return an _object_ from _query_interface_(), you must return the
-# same object each time for a given IID.  Note that you must return the same
-# _wrapped_ object
-# you
-# The rest are tested here.
-
-
-import pythoncom
-from win32com.server.util import wrap
-
-from .util import CheckClean
-
-numErrors = 0
-
-
-# Check that the 2 objects both have identical COM pointers.
-def CheckSameCOMObject(ob1, ob2):
-    addr1 = repr(ob1).split()[6][:-1]
-    addr2 = repr(ob2).split()[6][:-1]
-    return addr1 == addr2
-
-
-# Check that the objects conform to COM identity rules.
-def CheckObjectIdentity(ob1, ob2):
-    u1 = ob1.QueryInterface(pythoncom.IID_IUnknown)
-    u2 = ob2.QueryInterface(pythoncom.IID_IUnknown)
-    return CheckSameCOMObject(u1, u2)
-
-
-def FailObjectIdentity(ob1, ob2, when):
-    if not CheckObjectIdentity(ob1, ob2):
-        global numErrors
-        numErrors += 1
-        print(f"{when} are not identical ({ob1!r}, {ob2!r})")
-
-
-class Dummy:
-    _public_methods_ = []  # We never attempt to make a call on this object.
-    _com_interfaces_ = [pythoncom.IID_IPersistStorage]
-
-
-class Dummy2:
-    _public_methods_ = []  # We never attempt to make a call on this object.
-    _com_interfaces_ = [
-        pythoncom.IID_IPersistStorage,
-        pythoncom.IID_IExternalConnection,
-    ]
-
-
-class DelegatedDummy:
-    _public_methods_ = []
-
-
-class Dummy3:
-    _public_methods_ = []  # We never attempt to make a call on this object.
-    _com_interfaces_ = [pythoncom.IID_IPersistStorage]
-
-    def _query_interface_(self, iid):
-        if iid == pythoncom.IID_IExternalConnection:
-            # This will NEVER work - can only wrap the object once!
-            return wrap(DelegatedDummy())
-
-
-def TestGatewayInheritance():
-    # By default, wrap() creates and discards a temporary object.
-    # This is not necessary, but just the current implementation of wrap.
-    # As the object is correctly discarded, it doesn't affect this test.
-    o = wrap(Dummy(), pythoncom.IID_IPersistStorage)
-    o2 = o.QueryInterface(pythoncom.IID_IUnknown)
-    FailObjectIdentity(o, o2, "IID_IPersistStorage->IID_IUnknown")
-
-    o3 = o2.QueryInterface(pythoncom.IID_IDispatch)
-
-    FailObjectIdentity(o2, o3, "IID_IUnknown->IID_IDispatch")
-    FailObjectIdentity(o, o3, "IID_IPersistStorage->IID_IDispatch")
-
-    o4 = o3.QueryInterface(pythoncom.IID_IPersistStorage)
-    FailObjectIdentity(o, o4, "IID_IPersistStorage->IID_IPersistStorage(2)")
-    FailObjectIdentity(o2, o4, "IID_IUnknown->IID_IPersistStorage(2)")
-    FailObjectIdentity(o3, o4, "IID_IDispatch->IID_IPersistStorage(2)")
-
-    o5 = o4.QueryInterface(pythoncom.IID_IPersist)
-    FailObjectIdentity(o, o5, "IID_IPersistStorage->IID_IPersist")
-    FailObjectIdentity(o2, o5, "IID_IUnknown->IID_IPersist")
-    FailObjectIdentity(o3, o5, "IID_IDispatch->IID_IPersist")
-    FailObjectIdentity(o4, o5, "IID_IPersistStorage(2)->IID_IPersist")
-
-
-def TestMultiInterface():
-    o = wrap(Dummy2(), pythoncom.IID_IPersistStorage)
-    o2 = o.QueryInterface(pythoncom.IID_IExternalConnection)
-
-    FailObjectIdentity(o, o2, "IID_IPersistStorage->IID_IExternalConnection")
-
-    # Make the same QI again, to make sure it is stable.
-    o22 = o.QueryInterface(pythoncom.IID_IExternalConnection)
-    FailObjectIdentity(o, o22, "IID_IPersistStorage->IID_IExternalConnection")
-    FailObjectIdentity(
-        o2, o22, "IID_IPersistStorage->IID_IExternalConnection (stability)"
-    )
-
-    o3 = o2.QueryInterface(pythoncom.IID_IPersistStorage)
-    FailObjectIdentity(o2, o3, "IID_IExternalConnection->IID_IPersistStorage")
-    FailObjectIdentity(
-        o, o3, "IID_IPersistStorage->IID_IExternalConnection->IID_IPersistStorage"
-    )
-
-
-def test():
-    TestGatewayInheritance()
-    TestMultiInterface()
-    if numErrors == 0:
-        print("Worked ok")
-    else:
-        print("There were", numErrors, "errors.")
-
-
-if __name__ == "__main__":
-    test()
-    CheckClean()

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

@@ -1,140 +0,0 @@
-# Some raw iter tests.  Some "high-level" iterator tests can be found in
-# testvb.py and testOutlook.py
-import sys
-import unittest
-
-import pythoncom
-import win32com.server.util
-import win32com.test.util
-from win32com.client import Dispatch
-from win32com.client.gencache import EnsureDispatch
-
-
-class _BaseTestCase(win32com.test.util.TestCase):
-    def test_enumvariant_vb(self):
-        ob, iter = self.iter_factory()
-        got = []
-        for v in iter:
-            got.append(v)
-        self.assertEqual(got, self.expected_data)
-
-    def test_yield(self):
-        ob, i = self.iter_factory()
-        got = []
-        for v in iter(i):
-            got.append(v)
-        self.assertEqual(got, self.expected_data)
-
-    def _do_test_nonenum(self, object):
-        try:
-            for i in object:
-                pass
-            self.fail("Could iterate over a non-iterable object")
-        except TypeError:
-            pass  # this is expected.
-        self.assertRaises(TypeError, iter, object)
-        self.assertRaises(AttributeError, getattr, object, "next")
-
-    def test_nonenum_wrapper(self):
-        # Check our raw PyIDispatch
-        ob = self.object._oleobj_
-        try:
-            for i in ob:
-                pass
-            self.fail("Could iterate over a non-iterable object")
-        except TypeError:
-            pass  # this is expected.
-        self.assertRaises(TypeError, iter, ob)
-        self.assertRaises(AttributeError, getattr, ob, "next")
-
-        # And our Dispatch wrapper
-        ob = self.object
-        try:
-            for i in ob:
-                pass
-            self.fail("Could iterate over a non-iterable object")
-        except TypeError:
-            pass  # this is expected.
-        # Note that as our object may be dynamic, we *do* have a __getitem__
-        # method, meaning we *can* call iter() on the object.  In this case
-        # actual iteration is what fails.
-        # So either the 'iter(); will raise a type error, or an attempt to
-        # fetch it
-        try:
-            next(iter(ob))
-            self.fail("Expected a TypeError fetching this iterator")
-        except TypeError:
-            pass
-        # And it should never have a 'next' method
-        self.assertRaises(AttributeError, getattr, ob, "next")
-
-
-class VBTestCase(_BaseTestCase):
-    def setUp(self):
-        def factory():
-            # Our VB test harness exposes a property with IEnumVariant.
-            ob = self.object.EnumerableCollectionProperty
-            for i in self.expected_data:
-                ob.Add(i)
-            # Get the raw IEnumVARIANT.
-            invkind = pythoncom.DISPATCH_METHOD | pythoncom.DISPATCH_PROPERTYGET
-            iter = ob._oleobj_.InvokeTypes(
-                pythoncom.DISPID_NEWENUM, 0, invkind, (13, 10), ()
-            )
-            return ob, iter.QueryInterface(pythoncom.IID_IEnumVARIANT)
-
-        # We *need* generated dispatch semantics, so dynamic __getitem__ etc
-        # don't get in the way of our tests.
-        self.object = EnsureDispatch("PyCOMVBTest.Tester")
-        self.expected_data = [1, "Two", "3"]
-        self.iter_factory = factory
-
-    def tearDown(self):
-        self.object = None
-
-
-# Test our client semantics, but using a wrapped Python list object.
-# This has the effect of re-using our client specific tests, but in this
-# case is exercising the server side.
-class SomeObject:
-    _public_methods_ = ["GetCollection"]
-
-    def __init__(self, data):
-        self.data = data
-
-    def GetCollection(self):
-        return win32com.server.util.NewCollection(self.data)
-
-
-class WrappedPythonCOMServerTestCase(_BaseTestCase):
-    def setUp(self):
-        def factory():
-            ob = self.object.GetCollection()
-            flags = pythoncom.DISPATCH_METHOD | pythoncom.DISPATCH_PROPERTYGET
-            enum = ob._oleobj_.Invoke(pythoncom.DISPID_NEWENUM, 0, flags, 1)
-            return ob, enum.QueryInterface(pythoncom.IID_IEnumVARIANT)
-
-        self.expected_data = [1, "Two", 3]
-        sv = win32com.server.util.wrap(SomeObject(self.expected_data))
-        self.object = Dispatch(sv)
-        self.iter_factory = factory
-
-    def tearDown(self):
-        self.object = None
-
-
-def suite():
-    # We don't want our base class run
-    suite = unittest.TestSuite()
-    for item in globals().values():
-        if (
-            isinstance(item, type)
-            and issubclass(item, unittest.TestCase)
-            and item != _BaseTestCase
-        ):
-            suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(item))
-    return suite
-
-
-if __name__ == "__main__":
-    unittest.main(argv=sys.argv + ["suite"])