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

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

@@ -1,115 +0,0 @@
-import unittest
-
-import pythoncom
-import win32com.client
-import win32com.server.util
-import win32com.test.util
-import winerror
-
-
-# An object representing a list of numbers
-class PythonSemanticClass:
-    _public_methods_ = ["In"]  # DISPIDs are allocated.
-    _dispid_to_func_ = {10: "Add", 11: "Remove"}  # DISPIDs specified by the object.
-
-    def __init__(self):
-        self.list = []
-
-    def _NewEnum(self):
-        return win32com.server.util.NewEnum(self.list)
-
-    def _value_(self):
-        # should return an array.
-        return self.list
-
-    def _Evaluate(self):
-        # return the sum
-        return sum(self.list)
-
-    def In(self, value):
-        return value in self.list
-
-    def Add(self, value):
-        self.list.append(value)
-
-    def Remove(self, value):
-        self.list.remove(value)
-
-
-def DispExTest(ob):
-    if not __debug__:
-        print("WARNING: Tests dressed up as assertions are being skipped!")
-    assert ob.GetDispID("Add", 0) == 10, "Policy did not honour the dispid"
-    # Not impl
-    #       assert ob.GetMemberName(10, 0)=="add", "Policy did not give me the correct function for the dispid"
-    assert ob.GetDispID("Remove", 0) == 11, "Policy did not honour the dispid"
-    assert ob.GetDispID("In", 0) == 1000, "Allocated dispid unexpected value"
-    assert (
-        ob.GetDispID("_NewEnum", 0) == pythoncom.DISPID_NEWENUM
-    ), "_NewEnum() got unexpected DISPID"
-    dispids = []
-    dispid = -1
-    while 1:
-        try:
-            dispid = ob.GetNextDispID(0, dispid)
-            dispids.append(dispid)
-        except pythoncom.com_error as xxx_todo_changeme:
-            (hr, desc, exc, arg) = xxx_todo_changeme.args
-            assert hr == winerror.S_FALSE, "Bad result at end of enum"
-            break
-    dispids.sort()
-    assert dispids == [
-        pythoncom.DISPID_EVALUATE,
-        pythoncom.DISPID_NEWENUM,
-        10,
-        11,
-        1000,
-    ], f"Got back the wrong dispids: {dispids}"
-
-
-def SemanticTest(ob):
-    # First just check our object "generally" as expected.
-    ob.Add(1)
-    ob.Add(2)
-    ob.Add(3)
-    # invoke _value_
-    assert ob() == (1, 2, 3), f"Bad result - got {ob()!r}"
-
-    dispob = ob._oleobj_
-
-    rc = dispob.Invoke(
-        pythoncom.DISPID_EVALUATE,
-        0,
-        pythoncom.DISPATCH_METHOD | pythoncom.DISPATCH_PROPERTYGET,
-        1,
-    )
-    assert rc == 6, f"Evaluate returned {rc}"
-
-
-class Tester(win32com.test.util.TestCase):
-    def setUp(self):
-        debug = 0
-        import win32com.server.dispatcher
-
-        if debug:
-            dispatcher = win32com.server.dispatcher.DefaultDebugDispatcher
-        else:
-            dispatcher = None
-        disp = win32com.server.util.wrap(
-            PythonSemanticClass(), useDispatcher=dispatcher
-        )
-        self.ob = win32com.client.Dispatch(disp)
-
-    def tearDown(self):
-        self.ob = None
-
-    def testSemantics(self):
-        SemanticTest(self.ob)
-
-    def testIDispatchEx(self):
-        dispexob = self.ob._oleobj_.QueryInterface(pythoncom.IID_IDispatchEx)
-        DispExTest(dispexob)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,100 +0,0 @@
-import os
-import time
-
-import pythoncom
-from win32com.client import DispatchWithEvents, constants
-
-finished = 0  # Flag for the wait loop from (3) to test
-
-
-class ADOEvents:  # event handler class
-    def OnWillConnect(self, str, user, pw, opt, sts, cn):
-        # Must have this event, as if it is not handled, ADO assumes the
-        # operation is cancelled, and raises an error (Operation cancelled
-        # by the user)
-        pass
-
-    def OnConnectComplete(self, error, status, connection):
-        # Assume no errors, until we have the basic stuff
-        # working. Now, "connection" should be an open
-        # connection to my data source
-        # Do the "something" from (2). For now, just
-        # print the connection data source
-        print("connection is", connection)
-        print("Connected to", connection.Properties("Data Source"))
-        # OK, our work is done. Let the main loop know
-        global finished
-        finished = 1
-
-    def OnCommitTransComplete(self, pError, adStatus, pConnection):
-        pass
-
-    def OnInfoMessage(self, pError, adStatus, pConnection):
-        pass
-
-    def OnDisconnect(self, adStatus, pConnection):
-        pass
-
-    def OnBeginTransComplete(self, TransactionLevel, pError, adStatus, pConnection):
-        pass
-
-    def OnRollbackTransComplete(self, pError, adStatus, pConnection):
-        pass
-
-    def OnExecuteComplete(
-        self, RecordsAffected, pError, adStatus, pCommand, pRecordset, pConnection
-    ):
-        pass
-
-    def OnWillExecute(
-        self,
-        Source,
-        CursorType,
-        LockType,
-        Options,
-        adStatus,
-        pCommand,
-        pRecordset,
-        pConnection,
-    ):
-        pass
-
-
-def TestConnection(dbname):
-    # Create the ADO connection object, and link the event
-    # handlers into it
-    c = DispatchWithEvents("ADODB.Connection", ADOEvents)
-
-    # Initiate the asynchronous open
-    dsn = "Driver={Microsoft Access Driver (*.mdb)};Dbq=%s" % dbname
-    user = "system"
-    pw = "manager"
-    c.Open(dsn, user, pw, constants.adAsyncConnect)
-
-    # Sit in a loop, until our event handler (above) sets the
-    # "finished" flag or we time out.
-    end_time = time.clock() + 10
-    while time.clock() < end_time:
-        # Pump messages so that COM gets a look in
-        pythoncom.PumpWaitingMessages()
-    if not finished:
-        print("XXX - Failed to connect!")
-
-
-def Test():
-    from . import testAccess
-
-    try:
-        testAccess.GenerateSupport()
-    except pythoncom.com_error:
-        print("*** Can not import the MSAccess type libraries - tests skipped")
-        return
-    dbname = testAccess.CreateTestAccessDatabase()
-    try:
-        TestConnection(dbname)
-    finally:
-        os.unlink(dbname)
-
-
-if __name__ == "__main__":
-    Test()

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

@@ -1,44 +0,0 @@
-# Test AXScripting the best we can in an automated fashion...
-import os
-import sys
-
-import win32api
-import win32com.axscript
-import win32com.axscript.client
-import win32com.test.util
-
-verbose = "-v" in sys.argv
-
-
-class AXScript(win32com.test.util.TestCase):
-    def setUp(self):
-        file = win32api.GetFullPathName(
-            os.path.join(next(iter(win32com.axscript.client.__path__)), "pyscript.py")
-        )
-
-        self.verbose = verbose
-        win32com.test.util.RegisterPythonServer(file, "python", verbose=self.verbose)
-
-    def testHost(self):
-        file = win32api.GetFullPathName(
-            os.path.join(next(iter(win32com.axscript.__path__)), "test\\testHost.py")
-        )
-        cmd = f'{win32api.GetModuleFileName(0)} "{file}"'
-        if verbose:
-            print("Testing Python Scripting host")
-        win32com.test.util.ExecuteShellCommand(cmd, self)
-
-    def testCScript(self):
-        file = win32api.GetFullPathName(
-            os.path.join(
-                next(iter(win32com.axscript.__path__)), "Demos\\Client\\wsh\\test.pys"
-            )
-        )
-        cmd = 'cscript.exe "%s"' % (file)
-        if verbose:
-            print("Testing Windows Scripting host with Python script")
-        win32com.test.util.ExecuteShellCommand(cmd, self)
-
-
-if __name__ == "__main__":
-    win32com.test.util.testmain()

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

@@ -1,185 +0,0 @@
-#
-# This assumes that you have MSAccess and DAO installed.
-#  You need to run makepy.py over "msaccess.tlb" and
-#  "dao3032.dll", and ensure the generated files are on the
-#  path.
-
-# You can run this with no args, and a test database will be generated.
-# You can optionally pass a dbname on the command line, in which case it will be dumped.
-
-import os
-import sys
-
-import pythoncom
-import win32api
-from win32com.client import Dispatch, constants, gencache
-
-
-def CreateTestAccessDatabase(dbname=None):
-    # Creates a test access database - returns the filename.
-    if dbname is None:
-        dbname = os.path.join(win32api.GetTempPath(), "COMTestSuiteTempDatabase.mdb")
-
-    access = Dispatch("Access.Application")
-    dbEngine = access.DBEngine
-    workspace = dbEngine.Workspaces(0)
-
-    try:
-        os.unlink(dbname)
-    except OSError:
-        print(
-            "WARNING - Unable to delete old test database - expect a COM exception RSN!"
-        )
-
-    newdb = workspace.CreateDatabase(
-        dbname, constants.dbLangGeneral, constants.dbEncrypt
-    )
-
-    # Create one test table.
-    table = newdb.CreateTableDef("Test Table 1")
-    table.Fields.Append(table.CreateField("First Name", constants.dbText))
-    table.Fields.Append(table.CreateField("Last Name", constants.dbText))
-
-    index = table.CreateIndex("UniqueIndex")
-    index.Fields.Append(index.CreateField("First Name"))
-    index.Fields.Append(index.CreateField("Last Name"))
-    index.Unique = -1
-    table.Indexes.Append(index)
-
-    newdb.TableDefs.Append(table)
-
-    # Create a second test table.
-    table = newdb.CreateTableDef("Test Table 2")
-    table.Fields.Append(table.CreateField("First Name", constants.dbText))
-    table.Fields.Append(table.CreateField("Last Name", constants.dbText))
-
-    newdb.TableDefs.Append(table)
-
-    # Create a relationship between them
-    relation = newdb.CreateRelation("TestRelationship")
-    relation.Table = "Test Table 1"
-    relation.ForeignTable = "Test Table 2"
-
-    field = relation.CreateField("First Name")
-    field.ForeignName = "First Name"
-    relation.Fields.Append(field)
-
-    field = relation.CreateField("Last Name")
-    field.ForeignName = "Last Name"
-    relation.Fields.Append(field)
-
-    relation.Attributes = (
-        constants.dbRelationDeleteCascade + constants.dbRelationUpdateCascade
-    )
-
-    newdb.Relations.Append(relation)
-
-    # Finally we can add some data to the table.
-    tab1 = newdb.OpenRecordset("Test Table 1")
-    tab1.AddNew()
-    tab1.Fields("First Name").Value = "Mark"
-    tab1.Fields("Last Name").Value = "Hammond"
-    tab1.Update()
-
-    tab1.MoveFirst()
-    # We do a simple bookmark test which tests our optimized VT_SAFEARRAY|VT_UI1 support.
-    # The bookmark will be a buffer object - remember it for later.
-    bk = tab1.Bookmark
-
-    # Add a second record.
-    tab1.AddNew()
-    tab1.Fields("First Name").Value = "Second"
-    tab1.Fields("Last Name").Value = "Person"
-    tab1.Update()
-
-    # Reset the bookmark to the one we saved.
-    # But first check the test is actually doing something!
-    tab1.MoveLast()
-    assert (
-        tab1.Fields("First Name").Value == "Second"
-    ), "Unexpected record is last - makes bookmark test pointless!"
-
-    tab1.Bookmark = bk
-    assert tab1.Bookmark == bk, "The bookmark data is not the same"
-    assert (
-        tab1.Fields("First Name").Value == "Mark"
-    ), "The bookmark did not reset the record pointer correctly"
-
-    return dbname
-
-
-def DoDumpAccessInfo(dbname):
-    from . import daodump
-
-    a = forms = None
-    try:
-        sys.stderr.write("Creating Access Application...\n")
-        a = Dispatch("Access.Application")
-        print("Opening database %s" % dbname)
-        a.OpenCurrentDatabase(dbname)
-        db = a.CurrentDb()
-        daodump.DumpDB(db, 1)
-        forms = a.Forms
-        print("There are %d forms open." % (len(forms)))
-        # Uncommenting these lines means Access remains open.
-        # for form in forms:
-        #     print(f" {form.Name}")
-        reports = a.Reports
-        print("There are %d reports open" % (len(reports)))
-    finally:
-        if not a is None:
-            sys.stderr.write("Closing database\n")
-            try:
-                a.CloseCurrentDatabase()
-            except pythoncom.com_error:
-                pass
-
-
-# Generate all the support we can.
-def GenerateSupport():
-    # dao
-    gencache.EnsureModule("{00025E01-0000-0000-C000-000000000046}", 0, 4, 0)
-    # Access
-    #       gencache.EnsureModule("{4AFFC9A0-5F99-101B-AF4E-00AA003F0F07}", 0, 8, 0)
-    gencache.EnsureDispatch("Access.Application")
-
-
-def DumpAccessInfo(dbname):
-    amod = gencache.GetModuleForProgID("Access.Application")
-    dmod = gencache.GetModuleForProgID("DAO.DBEngine.35")
-    if amod is None and dmod is None:
-        DoDumpAccessInfo(dbname)
-        # Now generate all the support we can.
-        GenerateSupport()
-    else:
-        sys.stderr.write(
-            "testAccess not doing dynamic test, as generated code already exists\n"
-        )
-    # Now a generated version.
-    DoDumpAccessInfo(dbname)
-
-
-def test(dbname=None):
-    if dbname is None:
-        # We need makepy support to create a database (just for the constants!)
-        try:
-            GenerateSupport()
-        except pythoncom.com_error:
-            print("*** Can not import the MSAccess type libraries - tests skipped")
-            return
-        dbname = CreateTestAccessDatabase()
-        print("A test database at '%s' was created" % dbname)
-
-    DumpAccessInfo(dbname)
-
-
-if __name__ == "__main__":
-    from .util import CheckClean
-
-    dbname = None
-    if len(sys.argv) > 1:
-        dbname = sys.argv[1]
-
-    test(dbname)
-
-    CheckClean()

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

@@ -1,99 +0,0 @@
-# Originally contributed by Stefan Schukat as part of this arbitrary-sized
-# arrays patch.
-
-from win32com.client import gencache
-from win32com.test import util
-
-ZeroD = 0
-OneDEmpty = []
-OneD = [1, 2, 3]
-TwoD = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
-
-TwoD1 = [[[1, 2, 3, 5], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]
-
-OneD1 = [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]
-
-OneD2 = [
-    [1, 2, 3],
-    [1, 2, 3, 4, 5],
-    [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
-]
-
-
-ThreeD = [[[1, 2, 3], [1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]
-
-FourD = [
-    [
-        [[1, 2, 3], [1, 2, 3], [1, 2, 3]],
-        [[1, 2, 3], [1, 2, 3], [1, 2, 3]],
-        [[1, 2, 3], [1, 2, 3], [1, 2, 3]],
-    ],
-    [
-        [[1, 2, 3], [1, 2, 3], [1, 2, 3]],
-        [[1, 2, 3], [1, 2, 3], [1, 2, 3]],
-        [[1, 2, 3], [1, 2, 3], [1, 2, 3]],
-    ],
-]
-
-LargeD = [
-    [[list(range(10))] * 10],
-] * 512
-
-
-def _normalize_array(a):
-    if not isinstance(a, tuple):
-        return a
-    ret = []
-    for i in a:
-        ret.append(_normalize_array(i))
-    return ret
-
-
-class ArrayTest(util.TestCase):
-    def setUp(self):
-        self.arr = gencache.EnsureDispatch("PyCOMTest.ArrayTest")
-
-    def tearDown(self):
-        self.arr = None
-
-    def _doTest(self, array):
-        self.arr.Array = array
-        self.assertEqual(_normalize_array(self.arr.Array), array)
-
-    def testZeroD(self):
-        self._doTest(ZeroD)
-
-    def testOneDEmpty(self):
-        self._doTest(OneDEmpty)
-
-    def testOneD(self):
-        self._doTest(OneD)
-
-    def testTwoD(self):
-        self._doTest(TwoD)
-
-    def testThreeD(self):
-        self._doTest(ThreeD)
-
-    def testFourD(self):
-        self._doTest(FourD)
-
-    def testTwoD1(self):
-        self._doTest(TwoD1)
-
-    def testOneD1(self):
-        self._doTest(OneD1)
-
-    def testOneD2(self):
-        self._doTest(OneD2)
-
-    def testLargeD(self):
-        self._doTest(LargeD)
-
-
-if __name__ == "__main__":
-    try:
-        util.testmain()
-    except SystemExit as rc:
-        if not rc:
-            raise

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

@@ -1,169 +0,0 @@
-# testClipboard.py
-import unittest
-
-import pythoncom
-import win32clipboard
-import win32con
-import winerror
-from win32com.server.exception import COMException
-from win32com.server.util import NewEnum, wrap
-
-IDataObject_Methods = """GetData GetDataHere QueryGetData
-                         GetCanonicalFormatEtc SetData EnumFormatEtc
-                         DAdvise DUnadvise EnumDAdvise""".split()
-
-# A COM object implementing IDataObject used for basic testing.
-num_do_objects = 0
-
-
-def WrapCOMObject(ob, iid=None):
-    return wrap(ob, iid=iid, useDispatcher=0)
-
-
-class TestDataObject:
-    _com_interfaces_ = [pythoncom.IID_IDataObject]
-    _public_methods_ = IDataObject_Methods
-
-    def __init__(self, bytesval):
-        global num_do_objects
-        num_do_objects += 1
-        self.bytesval = bytesval
-        self.supported_fe = []
-        for cf in (win32con.CF_TEXT, win32con.CF_UNICODETEXT):
-            fe = cf, None, pythoncom.DVASPECT_CONTENT, -1, pythoncom.TYMED_HGLOBAL
-            self.supported_fe.append(fe)
-
-    def __del__(self):
-        global num_do_objects
-        num_do_objects -= 1
-
-    def _query_interface_(self, iid):
-        if iid == pythoncom.IID_IEnumFORMATETC:
-            return NewEnum(self.supported_fe, iid=iid)
-
-    def GetData(self, fe):
-        ret_stg = None
-        cf, target, aspect, index, tymed = fe
-        if aspect & pythoncom.DVASPECT_CONTENT and tymed == pythoncom.TYMED_HGLOBAL:
-            if cf == win32con.CF_TEXT:
-                ret_stg = pythoncom.STGMEDIUM()
-                ret_stg.set(pythoncom.TYMED_HGLOBAL, self.bytesval)
-            elif cf == win32con.CF_UNICODETEXT:
-                ret_stg = pythoncom.STGMEDIUM()
-                ret_stg.set(pythoncom.TYMED_HGLOBAL, self.bytesval.decode("latin1"))
-
-        if ret_stg is None:
-            raise COMException(hresult=winerror.E_NOTIMPL)
-        return ret_stg
-
-    def GetDataHere(self, fe):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def QueryGetData(self, fe):
-        cf, target, aspect, index, tymed = fe
-        if aspect & pythoncom.DVASPECT_CONTENT == 0:
-            raise COMException(hresult=winerror.DV_E_DVASPECT)
-        if tymed != pythoncom.TYMED_HGLOBAL:
-            raise COMException(hresult=winerror.DV_E_TYMED)
-        return None  # should check better
-
-    def GetCanonicalFormatEtc(self, fe):
-        raise COMException(winerror.DATA_S_SAMEFORMATETC)
-
-    def SetData(self, fe, medium):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def EnumFormatEtc(self, direction):
-        if direction != pythoncom.DATADIR_GET:
-            raise COMException(hresult=winerror.E_NOTIMPL)
-        return NewEnum(self.supported_fe, iid=pythoncom.IID_IEnumFORMATETC)
-
-    def DAdvise(self, fe, flags, sink):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def DUnadvise(self, connection):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def EnumDAdvise(self):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-
-class ClipboardTester(unittest.TestCase):
-    def setUp(self):
-        pythoncom.OleInitialize()
-
-    def tearDown(self):
-        try:
-            pythoncom.OleFlushClipboard()
-        except pythoncom.com_error:
-            # We never set anything!
-            pass
-
-    def testIsCurrentClipboard(self):
-        do = TestDataObject(b"Hello from Python")
-        do = WrapCOMObject(do, iid=pythoncom.IID_IDataObject)
-        pythoncom.OleSetClipboard(do)
-        self.assertTrue(pythoncom.OleIsCurrentClipboard(do))
-
-    def testComToWin32(self):
-        # Set the data via our DataObject
-        do = TestDataObject(b"Hello from Python")
-        do = WrapCOMObject(do, iid=pythoncom.IID_IDataObject)
-        pythoncom.OleSetClipboard(do)
-        # Then get it back via the standard win32 clipboard functions.
-        win32clipboard.OpenClipboard()
-        got = win32clipboard.GetClipboardData(win32con.CF_TEXT)
-        # CF_TEXT gives bytes.
-        expected = b"Hello from Python"
-        self.assertEqual(got, expected)
-        # Now check unicode
-        got = win32clipboard.GetClipboardData(win32con.CF_UNICODETEXT)
-        self.assertEqual(got, "Hello from Python")
-        win32clipboard.CloseClipboard()
-
-    def testWin32ToCom(self):
-        # Set the data via the std win32 clipboard functions.
-        val = b"Hello again!"  # always bytes
-        win32clipboard.OpenClipboard()
-        win32clipboard.SetClipboardData(win32con.CF_TEXT, val)
-        win32clipboard.CloseClipboard()
-        # and get it via an IDataObject provided by COM
-        do = pythoncom.OleGetClipboard()
-        cf = (
-            win32con.CF_TEXT,
-            None,
-            pythoncom.DVASPECT_CONTENT,
-            -1,
-            pythoncom.TYMED_HGLOBAL,
-        )
-        stg = do.GetData(cf)
-        got = stg.data
-        # The data we get back has the \0, as our STGMEDIUM has no way of
-        # knowing if it meant to be a string, or a binary buffer, so
-        # it must return it too.
-        self.assertTrue(got, b"Hello again!\0")
-
-    def testDataObjectFlush(self):
-        do = TestDataObject(b"Hello from Python")
-        do = WrapCOMObject(do, iid=pythoncom.IID_IDataObject)
-        pythoncom.OleSetClipboard(do)
-        self.assertEqual(num_do_objects, 1)
-
-        do = None  # clear my ref!
-        pythoncom.OleFlushClipboard()
-        self.assertEqual(num_do_objects, 0)
-
-    def testDataObjectReset(self):
-        do = TestDataObject(b"Hello from Python")
-        do = WrapCOMObject(do)
-        pythoncom.OleSetClipboard(do)
-        do = None  # clear my ref!
-        self.assertEqual(num_do_objects, 1)
-        pythoncom.OleSetClipboard(None)
-        self.assertEqual(num_do_objects, 0)
-
-
-if __name__ == "__main__":
-    from win32com.test import util
-
-    util.testmain()