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

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

@@ -1,159 +0,0 @@
-# testCollections.py
-#
-# This code tests both the client and server side of collections
-# and enumerators.
-#
-# Also has the side effect of testing some of the PythonCOM error semantics.
-import sys
-import unittest
-
-import pythoncom
-import win32com.client
-import win32com.server.util
-import win32com.test.util
-import winerror
-
-
-def MakeEmptyEnum():
-    # create the Python enumerator object as a real COM object
-    o = win32com.server.util.wrap(win32com.server.util.Collection())
-    return win32com.client.Dispatch(o)
-
-
-def MakeTestEnum():
-    # create a sub-collection, just to make sure it works :-)
-    sub = win32com.server.util.wrap(
-        win32com.server.util.Collection(["Sub1", 2, "Sub3"])
-    )
-    # create the Python enumerator object as a real COM object
-    o = win32com.server.util.wrap(win32com.server.util.Collection([1, "Two", 3, sub]))
-    return win32com.client.Dispatch(o)
-
-
-def TestEnumAgainst(o, check):
-    for i in range(len(check)):
-        assert (
-            o(i) == check[i]
-        ), f"Using default method gave the incorrect value - {o(i)!r}/{check[i]!r}"
-
-    for i in range(len(check)):
-        assert (
-            o.Item(i) == check[i]
-        ), f"Using Item method gave the incorrect value - {o(i)!r}/{check[i]!r}"
-
-    # First try looping.
-    cmp = []
-    for s in o:
-        cmp.append(s)
-
-    assert (
-        cmp[: len(check)] == check
-    ), f"Result after looping isn't correct - {cmp[: len(check)]!r}/{check!r}"
-
-    for i in range(len(check)):
-        assert o[i] == check[i], "Using indexing gave the incorrect value"
-
-
-def TestEnum(quiet=None):
-    if quiet is None:
-        quiet = not "-v" in sys.argv
-    if not quiet:
-        print("Simple enum test")
-    o = MakeTestEnum()
-    check = [1, "Two", 3]
-    TestEnumAgainst(o, check)
-
-    if not quiet:
-        print("sub-collection test")
-    sub = o[3]
-    TestEnumAgainst(sub, ["Sub1", 2, "Sub3"])
-
-    # Remove the sublist for this test!
-    o.Remove(o.Count() - 1)
-
-    if not quiet:
-        print("Remove item test")
-    del check[1]
-    o.Remove(1)
-    TestEnumAgainst(o, check)
-
-    if not quiet:
-        print("Add item test")
-    o.Add("New Item")
-    check.append("New Item")
-    TestEnumAgainst(o, check)
-
-    if not quiet:
-        print("Insert item test")
-    o.Insert(2, -1)
-    check.insert(2, -1)
-    TestEnumAgainst(o, check)
-
-    ### This does not work!
-    # if not quiet: print("Indexed replace item test")
-    # o[2] = 'Replaced Item'
-    # check[2] = 'Replaced Item'
-    # TestEnumAgainst(o, check)
-
-    try:
-        o()
-        raise AssertionError(
-            "default method with no args worked when it shouldn't have!"
-        )
-    except pythoncom.com_error as exc:
-        assert (
-            exc.hresult == winerror.DISP_E_BADPARAMCOUNT
-        ), f"Expected DISP_E_BADPARAMCOUNT - got {exc}"
-
-    try:
-        o.Insert("foo", 2)
-        raise AssertionError("Insert worked when it shouldn't have!")
-    except pythoncom.com_error as exc:
-        assert (
-            exc.hresult == winerror.DISP_E_TYPEMISMATCH
-        ), f"Expected DISP_E_TYPEMISMATCH - got {exc}"
-
-    # Remove the sublist for this test!
-    try:
-        o.Remove(o.Count())
-        raise AssertionError("Remove worked when it shouldn't have!")
-    except pythoncom.com_error as exc:
-        assert (
-            exc.hresult == winerror.DISP_E_BADINDEX
-        ), f"Expected DISP_E_BADINDEX - got {exc}"
-
-    # Test an empty collection
-    if not quiet:
-        print("Empty collection test")
-    o = MakeEmptyEnum()
-    for item in o:
-        raise AssertionError("Empty list performed an iteration")
-
-    try:
-        ob = o[1]
-        raise AssertionError("Empty list could be indexed")
-    except IndexError:
-        pass
-
-    try:
-        ob = o[0]
-        raise AssertionError("Empty list could be indexed")
-    except IndexError:
-        pass
-
-    try:
-        ob = o(0)
-        raise AssertionError("Empty list could be indexed")
-    except pythoncom.com_error as exc:
-        assert (
-            exc.hresult == winerror.DISP_E_BADINDEX
-        ), f"Expected DISP_E_BADINDEX - got {exc}"
-
-
-class TestCase(win32com.test.util.TestCase):
-    def testEnum(self):
-        TestEnum()
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,35 +0,0 @@
-import unittest
-
-import win32com.client
-import win32com.server.util
-import win32com.test.util
-
-
-class Tester:
-    _public_methods_ = ["TestValue"]
-
-    def TestValue(self, v):
-        pass
-
-
-def test_ob():
-    return win32com.client.Dispatch(win32com.server.util.wrap(Tester()))
-
-
-class TestException(Exception):
-    pass
-
-
-# The object we try and pass - pywin32 will call __float__ as a last resort.
-class BadConversions:
-    def __float__(self):
-        raise TestException
-
-
-class TestCase(win32com.test.util.TestCase):
-    def test_float(self):
-        self.assertRaises(TestException, test_ob().TestValue, BadConversions())
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,50 +0,0 @@
-# testDCOM
-usage = """\
-testDCOM.py - Simple DCOM test
-Usage: testDCOM.py serverName
-
-Attempts to start the Python.Interpreter object on the named machine,
-and checks that the object is indeed running remotely.
-
-Requires the named server be configured to run DCOM (using dcomcnfg.exe),
-and the Python.Interpreter object installed and registered on that machine.
-
-The Python.Interpreter object must be installed on the local machine,
-but no special DCOM configuration should be necessary.
-"""
-import sys
-
-# NOTE: If you configured the object locally using dcomcnfg, you could
-# simple use Dispatch rather than DispatchEx.
-import pythoncom
-import win32api
-import win32com.client
-
-
-def test(serverName):
-    if serverName.lower() == win32api.GetComputerName().lower():
-        print("You must specify a remote server name, not the local machine!")
-        return
-
-    # Hack to overcome a DCOM limitation.  As the Python.Interpreter object
-    # is probably installed locally as an InProc object, DCOM seems to ignore
-    # all settings, and use the local object.
-    clsctx = pythoncom.CLSCTX_SERVER & ~pythoncom.CLSCTX_INPROC_SERVER
-    ob = win32com.client.DispatchEx("Python.Interpreter", serverName, clsctx=clsctx)
-    ob.Exec("import win32api")
-    actualName = ob.Eval("win32api.GetComputerName()")
-    if serverName.lower() != actualName.lower():
-        print(
-            "Error: The object created on server '{}' reported its name as '{}'".format(
-                serverName, actualName
-            )
-        )
-    else:
-        print("Object created and tested OK on server '%s'" % serverName)
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 2:
-        test(sys.argv[1])
-    else:
-        print(usage)

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

@@ -1,74 +0,0 @@
-import unittest
-from datetime import datetime
-
-import pywintypes
-import win32com.client
-import win32com.server.util
-import win32com.test.util
-from win32timezone import TimeZoneInfo
-
-
-# A COM object so we can pass dates to and from the COM boundary.
-class Tester:
-    _public_methods_ = ["TestDate"]
-
-    def TestDate(self, d):
-        assert isinstance(d, datetime)
-        return d
-
-
-def test_ob():
-    return win32com.client.Dispatch(win32com.server.util.wrap(Tester()))
-
-
-class TestCase(win32com.test.util.TestCase):
-    def check(self, d, expected=None):
-        if not issubclass(pywintypes.TimeType, datetime):
-            self.skipTest("this is testing pywintypes and datetime")
-        got = test_ob().TestDate(d)
-        self.assertEqual(got, expected or d)
-
-    def testUTC(self):
-        self.check(
-            datetime(
-                year=2000,
-                month=12,
-                day=25,
-                microsecond=500000,
-                tzinfo=TimeZoneInfo.utc(),
-            )
-        )
-
-    def testLocal(self):
-        self.check(
-            datetime(
-                year=2000,
-                month=12,
-                day=25,
-                microsecond=500000,
-                tzinfo=TimeZoneInfo.local(),
-            )
-        )
-
-    def testMSTruncated(self):
-        # milliseconds are kept but microseconds are lost after rounding.
-        self.check(
-            datetime(
-                year=2000,
-                month=12,
-                day=25,
-                microsecond=500500,
-                tzinfo=TimeZoneInfo.utc(),
-            ),
-            datetime(
-                year=2000,
-                month=12,
-                day=25,
-                microsecond=500000,
-                tzinfo=TimeZoneInfo.utc(),
-            ),
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,101 +0,0 @@
-# testDictionary.py
-#
-import sys
-import unittest
-
-import pythoncom
-import pywintypes
-import win32com.client
-import win32com.server.util
-import win32com.test.util
-import win32timezone
-import winerror
-
-
-def MakeTestDictionary():
-    return win32com.client.Dispatch("Python.Dictionary")
-
-
-def TestDictAgainst(dict, check):
-    for key, value in check.items():
-        assert (
-            dict(key) == value
-        ), f"Indexing for '{key!r}' gave the incorrect value - {dict[key]!r}/{check[key]!r}"
-
-
-# Ensure we have the correct version registered.
-def Register(quiet):
-    import win32com.servers.dictionary
-
-    win32com.test.util.RegisterPythonServer(
-        win32com.servers.dictionary.__file__, "Python.Dictionary"
-    )
-
-
-def TestDict(quiet=None):
-    if quiet is None:
-        quiet = not "-v" in sys.argv
-    Register(quiet)
-
-    if not quiet:
-        print("Simple enum test")
-    dict = MakeTestDictionary()
-    checkDict = {}
-    TestDictAgainst(dict, checkDict)
-
-    dict["NewKey"] = "NewValue"
-    checkDict["NewKey"] = "NewValue"
-    TestDictAgainst(dict, checkDict)
-
-    dict["NewKey"] = None
-    del checkDict["NewKey"]
-    TestDictAgainst(dict, checkDict)
-
-    now = win32timezone.now()
-    # We want to keep the milliseconds but discard microseconds as they
-    # don't survive the conversion.
-    now = now.replace(microsecond=round(now.microsecond / 1000) * 1000)
-    dict["Now"] = now
-    checkDict["Now"] = now
-    TestDictAgainst(dict, checkDict)
-
-    if not quiet:
-        print("Failure tests")
-    try:
-        dict()
-        raise Exception("default method with no args worked when it shouldn't have!")
-    except pythoncom.com_error as xxx_todo_changeme:
-        (hr, desc, exc, argErr) = xxx_todo_changeme.args
-        assert (
-            hr == winerror.DISP_E_BADPARAMCOUNT
-        ), f"Expected DISP_E_BADPARAMCOUNT - got {hr} ({desc})"
-
-    try:
-        dict("hi", "there")
-        raise Exception("multiple args worked when it shouldn't have!")
-    except pythoncom.com_error as xxx_todo_changeme1:
-        (hr, desc, exc, argErr) = xxx_todo_changeme1.args
-        assert (
-            hr == winerror.DISP_E_BADPARAMCOUNT
-        ), f"Expected DISP_E_BADPARAMCOUNT - got {hr} ({desc})"
-
-    try:
-        dict(0)
-        raise Exception("int key worked when it shouldn't have!")
-    except pythoncom.com_error as xxx_todo_changeme2:
-        (hr, desc, exc, argErr) = xxx_todo_changeme2.args
-        assert (
-            hr == winerror.DISP_E_TYPEMISMATCH
-        ), f"Expected DISP_E_TYPEMISMATCH - got {hr} ({desc})"
-
-    if not quiet:
-        print("Python.Dictionary tests complete.")
-
-
-class TestCase(win32com.test.util.TestCase):
-    def testDict(self):
-        TestDict()
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,83 +0,0 @@
-# Test dynamic policy, and running object table.
-
-import pythoncom
-import winerror
-from win32com.server.exception import COMException
-
-iid = pythoncom.MakeIID("{b48969a0-784b-11d0-ae71-d23f56000000}")
-
-
-class VeryPermissive:
-    def _dynamic_(self, name, lcid, wFlags, args):
-        if wFlags & pythoncom.DISPATCH_METHOD:
-            return getattr(self, name)(*args)
-
-        if wFlags & pythoncom.DISPATCH_PROPERTYGET:
-            try:
-                # to avoid problems with byref param handling, tuple results are converted to lists.
-                ret = self.__dict__[name]
-                if isinstance(ret, tuple):
-                    ret = list(ret)
-                return ret
-            except KeyError:  # Probably a method request.
-                raise COMException(scode=winerror.DISP_E_MEMBERNOTFOUND)
-
-        if wFlags & (
-            pythoncom.DISPATCH_PROPERTYPUT | pythoncom.DISPATCH_PROPERTYPUTREF
-        ):
-            setattr(self, name, args[0])
-            return
-
-        raise COMException(scode=winerror.E_INVALIDARG, desc="invalid wFlags")
-
-    def write(self, *args):
-        if len(args) == 0:
-            raise COMException(
-                scode=winerror.DISP_E_BADPARAMCOUNT
-            )  # Probably call as PROPGET.
-
-        for arg in args[:-1]:
-            print(arg, end=" ")
-        print(args[-1])
-
-
-def Test():
-    import win32com.server.policy
-    import win32com.server.util
-
-    #       import win32dbg;win32dbg.brk()
-    ob = win32com.server.util.wrap(
-        VeryPermissive(), usePolicy=win32com.server.policy.DynamicPolicy
-    )
-    try:
-        handle = pythoncom.RegisterActiveObject(ob, iid, 0)
-    except pythoncom.com_error as details:
-        print("Warning - could not register the object in the ROT:", details)
-        handle = None
-    try:
-        import win32com.client.dynamic
-
-        client = win32com.client.dynamic.Dispatch(iid)
-        client.ANewAttr = "Hello"
-        assert client.ANewAttr == "Hello", "Could not set dynamic property"
-
-        v = ["Hello", "From", "Python", 1.4]
-        client.TestSequence = v
-        assert v == list(
-            client.TestSequence
-        ), f"Dynamic sequences not working! {v!r}/{client.testSequence!r}"
-
-        client.write("This", "output", "has", "come", "via", "testDynamic.py")
-        # Check our new "_FlagAsMethod" works (kinda!)
-        client._FlagAsMethod("NotReallyAMethod")
-        assert callable(client.NotReallyAMethod), "Method I flagged as callable isn't!"
-
-        client = None
-    finally:
-        if handle is not None:
-            pythoncom.RevokeActiveObject(handle)
-    print("Test worked!")
-
-
-if __name__ == "__main__":
-    Test()

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

@@ -1,121 +0,0 @@
-# TestExchange = Exchange Server Dump
-# Note that this code uses "CDO", which is unlikely to get the best choice.
-# You should use the Outlook object model, or
-# the win32com.mapi examples for a low-level interface.
-
-import os
-
-import pythoncom
-from win32com.client import gencache
-
-ammodule = None  # was the generated module!
-
-
-def GetDefaultProfileName():
-    import win32api
-    import win32con
-
-    try:
-        key = win32api.RegOpenKey(
-            win32con.HKEY_CURRENT_USER,
-            "Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows Messaging Subsystem\\Profiles",
-        )
-        try:
-            return win32api.RegQueryValueEx(key, "DefaultProfile")[0]
-        finally:
-            key.Close()
-    except win32api.error:
-        return None
-
-
-#
-# Recursive dump of folders.
-#
-def DumpFolder(folder, indent=0):
-    print(" " * indent, folder.Name)
-    folders = folder.Folders
-    folder = folders.GetFirst()
-    while folder:
-        DumpFolder(folder, indent + 1)
-        folder = folders.GetNext()
-
-
-def DumpFolders(session):
-    try:
-        infostores = session.InfoStores
-    except AttributeError:
-        # later outlook?
-        store = session.DefaultStore
-        folder = store.GetRootFolder()
-        DumpFolder(folder)
-        return
-
-    print(infostores)
-    print("There are %d infostores" % infostores.Count)
-    for i in range(infostores.Count):
-        infostore = infostores[i + 1]
-        print("Infostore = ", infostore.Name)
-        try:
-            folder = infostore.RootFolder
-        except pythoncom.com_error as details:
-            hr, msg, exc, arg = details
-            # -2147221219 == MAPI_E_FAILONEPROVIDER - a single provider temporarily not available.
-            if exc and exc[-1] == -2147221219:
-                print("This info store is currently not available")
-                continue
-        DumpFolder(folder)
-
-
-# Build a dictionary of property tags, so I can reverse look-up
-#
-PropTagsById = {}
-if ammodule:
-    for name, val in ammodule.constants.__dict__.items():
-        PropTagsById[val] = name
-
-
-def TestAddress(session):
-    # entry = session.GetAddressEntry("Skip")
-    # print(entry)
-    pass
-
-
-def TestUser(session):
-    ae = session.CurrentUser
-    fields = getattr(ae, "Fields", [])
-    print("User has %d fields" % len(fields))
-    for f in range(len(fields)):
-        field = fields[f + 1]
-        id = PropTagsById.get(field.ID, field.ID)
-        print(f"{field.Name}/{id}={field.Value}")
-
-
-def test():
-    oldcwd = os.getcwd()
-    try:
-        session = gencache.EnsureDispatch("MAPI.Session")
-        try:
-            session.Logon(GetDefaultProfileName())
-        except pythoncom.com_error as details:
-            print("Could not log on to MAPI:", details)
-            return
-    except pythoncom.error:
-        # no mapi.session - let's try outlook
-        app = gencache.EnsureDispatch("Outlook.Application")
-        session = app.Session
-
-    try:
-        TestUser(session)
-        TestAddress(session)
-        DumpFolders(session)
-    finally:
-        session.Logoff()
-        # It appears Exchange will change the cwd on us :(
-        os.chdir(oldcwd)
-
-
-if __name__ == "__main__":
-    from .util import CheckClean
-
-    test()
-    CheckClean()