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

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

@@ -1,29 +0,0 @@
-import unittest
-
-import pythoncom
-import win32com.test.util
-import winerror
-
-
-class TestROT(win32com.test.util.TestCase):
-    def testit(self):
-        ctx = pythoncom.CreateBindCtx()
-        rot = pythoncom.GetRunningObjectTable()
-        num = 0
-        for mk in rot:
-            name = mk.GetDisplayName(ctx, None)
-            num += 1
-            # Monikers themselves can iterate their contents (sometimes :)
-            try:
-                for sub in mk:
-                    num += 1
-            except pythoncom.com_error as exc:
-                if exc.hresult != winerror.E_NOTIMPL:
-                    raise
-
-        # if num < 2:
-        #     print("Only", num, "objects in the ROT - this is unusual")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,51 +0,0 @@
-import unittest
-
-import pythoncom
-import win32com.client.dynamic
-import win32com.test.util
-import winerror
-
-
-def TestConnections():
-    import win32com.demos.connect
-
-    win32com.demos.connect.test()
-
-
-class InterpCase(win32com.test.util.TestCase):
-    def setUp(self):
-        # Ensure the correct version registered.
-        from win32com.servers import interp
-
-        win32com.test.util.RegisterPythonServer(interp.__file__, "Python.Interpreter")
-
-    def _testInterp(self, interp):
-        self.assertEqual(interp.Eval("1+1"), 2)
-        win32com.test.util.assertRaisesCOM_HRESULT(
-            self, winerror.DISP_E_TYPEMISMATCH, interp.Eval, 2
-        )
-
-    def testInproc(self):
-        interp = win32com.client.dynamic.Dispatch(
-            "Python.Interpreter", clsctx=pythoncom.CLSCTX_INPROC
-        )
-        self._testInterp(interp)
-
-    def testLocalServer(self):
-        interp = win32com.client.dynamic.Dispatch(
-            "Python.Interpreter", clsctx=pythoncom.CLSCTX_LOCAL_SERVER
-        )
-        self._testInterp(interp)
-
-    def testAny(self):
-        interp = win32com.client.dynamic.Dispatch("Python.Interpreter")
-        self._testInterp(interp)
-
-
-class ConnectionsTestCase(win32com.test.util.TestCase):
-    def testConnections(self):
-        TestConnections()
-
-
-if __name__ == "__main__":
-    unittest.main("testServers")

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

@@ -1,272 +0,0 @@
-import datetime
-import os
-import struct
-import sys
-
-import pythoncom
-import pywintypes
-import win32com.test.util
-import win32con
-import win32timezone
-from win32com.shell import shell
-from win32com.shell.shellcon import *
-from win32com.storagecon import *
-
-
-class ShellTester(win32com.test.util.TestCase):
-    def testShellLink(self):
-        desktop = str(shell.SHGetSpecialFolderPath(0, CSIDL_DESKTOP))
-        num = 0
-        shellLink = pythoncom.CoCreateInstance(
-            shell.CLSID_ShellLink,
-            None,
-            pythoncom.CLSCTX_INPROC_SERVER,
-            shell.IID_IShellLink,
-        )
-        persistFile = shellLink.QueryInterface(pythoncom.IID_IPersistFile)
-        names = [os.path.join(desktop, n) for n in os.listdir(desktop)]
-        programs = str(shell.SHGetSpecialFolderPath(0, CSIDL_PROGRAMS))
-        names.extend([os.path.join(programs, n) for n in os.listdir(programs)])
-        for name in names:
-            try:
-                persistFile.Load(name, STGM_READ)
-            except pythoncom.com_error:
-                continue
-            # Resolve is slow - avoid it for our tests.
-            # shellLink.Resolve(0, shell.SLR_ANY_MATCH | shell.SLR_NO_UI)
-            fname, findData = shellLink.GetPath(0)
-            unc = shellLink.GetPath(shell.SLGP_UNCPRIORITY)[0]
-            num += 1
-        if num == 0:
-            # This isn't a fatal error, but is unlikely.
-            print(
-                "Could not find any links on your desktop or programs dir, which is unusual"
-            )
-
-    def testShellFolder(self):
-        sf = shell.SHGetDesktopFolder()
-        names_1 = []
-        for i in sf:  # Magically calls EnumObjects
-            name = sf.GetDisplayNameOf(i, SHGDN_NORMAL)
-            names_1.append(name)
-
-        # And get the enumerator manually
-        enum = sf.EnumObjects(
-            0, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN
-        )
-        names_2 = []
-        for i in enum:
-            name = sf.GetDisplayNameOf(i, SHGDN_NORMAL)
-            names_2.append(name)
-        names_1.sort()
-        names_2.sort()
-        self.assertEqual(names_1, names_2)
-
-
-class PIDLTester(win32com.test.util.TestCase):
-    def _rtPIDL(self, pidl):
-        pidl_str = shell.PIDLAsString(pidl)
-        pidl_rt = shell.StringAsPIDL(pidl_str)
-        self.assertEqual(pidl_rt, pidl)
-        pidl_str_rt = shell.PIDLAsString(pidl_rt)
-        self.assertEqual(pidl_str_rt, pidl_str)
-
-    def _rtCIDA(self, parent, kids):
-        cida = parent, kids
-        cida_str = shell.CIDAAsString(cida)
-        cida_rt = shell.StringAsCIDA(cida_str)
-        self.assertEqual(cida, cida_rt)
-        cida_str_rt = shell.CIDAAsString(cida_rt)
-        self.assertEqual(cida_str_rt, cida_str)
-
-    def testPIDL(self):
-        # A PIDL of "\1" is: cb + pidl + cb
-        expect = b"\03\00" + b"\1" + b"\0\0"
-        self.assertEqual(shell.PIDLAsString([b"\1"]), expect)
-        self._rtPIDL([b"\0"])
-        self._rtPIDL([b"\1", b"\2", b"\3"])
-        self._rtPIDL([b"\0" * 2048] * 2048)
-        # PIDL must be a list
-        self.assertRaises(TypeError, shell.PIDLAsString, "foo")
-
-    def testCIDA(self):
-        self._rtCIDA([b"\0"], [[b"\0"]])
-        self._rtCIDA([b"\1"], [[b"\2"]])
-        self._rtCIDA([b"\0"], [[b"\0"], [b"\1"], [b"\2"]])
-
-    def testBadShortPIDL(self):
-        # A too-short child element: cb + pidl + cb
-        pidl = b"\01\00" + b"\1"
-        self.assertRaises(ValueError, shell.StringAsPIDL, pidl)
-
-        # ack - tried to test too long PIDLs, but a len of 0xFFFF may not
-        # always fail.
-
-
-class FILEGROUPDESCRIPTORTester(win32com.test.util.TestCase):
-    def _getTestTimes(self):
-        if issubclass(pywintypes.TimeType, datetime.datetime):
-            ctime = win32timezone.now()
-            # FILETIME only has ms precision...
-            ctime = ctime.replace(microsecond=ctime.microsecond // 1000 * 1000)
-            atime = ctime + datetime.timedelta(seconds=1)
-            wtime = atime + datetime.timedelta(seconds=1)
-        else:
-            ctime = pywintypes.Time(11)
-            atime = pywintypes.Time(12)
-            wtime = pywintypes.Time(13)
-        return ctime, atime, wtime
-
-    def _testRT(self, fd):
-        fgd_string = shell.FILEGROUPDESCRIPTORAsString([fd])
-        fd2 = shell.StringAsFILEGROUPDESCRIPTOR(fgd_string)[0]
-
-        fd = fd.copy()
-        fd2 = fd2.copy()
-
-        # The returned objects *always* have dwFlags and cFileName.
-        if "dwFlags" not in fd:
-            del fd2["dwFlags"]
-        if "cFileName" not in fd:
-            self.assertEqual(fd2["cFileName"], "")
-            del fd2["cFileName"]
-
-        self.assertEqual(fd, fd2)
-
-    def _testSimple(self, make_unicode):
-        fgd = shell.FILEGROUPDESCRIPTORAsString([], make_unicode)
-        header = struct.pack("i", 0)
-        self.assertEqual(header, fgd[: len(header)])
-        self._testRT({})
-        d = {}
-        fgd = shell.FILEGROUPDESCRIPTORAsString([d], make_unicode)
-        header = struct.pack("i", 1)
-        self.assertEqual(header, fgd[: len(header)])
-        self._testRT(d)
-
-    def testSimpleBytes(self):
-        self._testSimple(False)
-
-    def testSimpleUnicode(self):
-        self._testSimple(True)
-
-    def testComplex(self):
-        clsid = pythoncom.MakeIID("{CD637886-DB8B-4b04-98B5-25731E1495BE}")
-        ctime, atime, wtime = self._getTestTimes()
-        d = {
-            "cFileName": "foo.txt",
-            "clsid": clsid,
-            "sizel": (1, 2),
-            "pointl": (3, 4),
-            "dwFileAttributes": win32con.FILE_ATTRIBUTE_NORMAL,
-            "ftCreationTime": ctime,
-            "ftLastAccessTime": atime,
-            "ftLastWriteTime": wtime,
-            "nFileSize": sys.maxsize + 1,
-        }
-        self._testRT(d)
-
-    def testUnicode(self):
-        # exercise a bug fixed in build 210 - multiple unicode objects failed.
-        ctime, atime, wtime = self._getTestTimes()
-        d = [
-            {
-                "cFileName": "foo.txt",
-                "sizel": (1, 2),
-                "pointl": (3, 4),
-                "dwFileAttributes": win32con.FILE_ATTRIBUTE_NORMAL,
-                "ftCreationTime": ctime,
-                "ftLastAccessTime": atime,
-                "ftLastWriteTime": wtime,
-                "nFileSize": sys.maxsize + 1,
-            },
-            {
-                "cFileName": "foo2.txt",
-                "sizel": (1, 2),
-                "pointl": (3, 4),
-                "dwFileAttributes": win32con.FILE_ATTRIBUTE_NORMAL,
-                "ftCreationTime": ctime,
-                "ftLastAccessTime": atime,
-                "ftLastWriteTime": wtime,
-                "nFileSize": sys.maxsize + 1,
-            },
-            {
-                "cFileName": "foo\xa9.txt",
-                "sizel": (1, 2),
-                "pointl": (3, 4),
-                "dwFileAttributes": win32con.FILE_ATTRIBUTE_NORMAL,
-                "ftCreationTime": ctime,
-                "ftLastAccessTime": atime,
-                "ftLastWriteTime": wtime,
-                "nFileSize": sys.maxsize + 1,
-            },
-        ]
-        s = shell.FILEGROUPDESCRIPTORAsString(d, 1)
-        d2 = shell.StringAsFILEGROUPDESCRIPTOR(s)
-        # clobber 'dwFlags' - they are not expected to be identical
-        for t in d2:
-            del t["dwFlags"]
-        self.assertEqual(d, d2)
-
-
-class FileOperationTester(win32com.test.util.TestCase):
-    def setUp(self):
-        import tempfile
-
-        self.src_name = os.path.join(tempfile.gettempdir(), "pywin32_testshell")
-        self.dest_name = os.path.join(tempfile.gettempdir(), "pywin32_testshell_dest")
-        self.test_data = b"Hello from\0Python"
-        f = open(self.src_name, "wb")
-        f.write(self.test_data)
-        f.close()
-        try:
-            os.unlink(self.dest_name)
-        except OSError:
-            pass
-
-    def tearDown(self):
-        for fname in (self.src_name, self.dest_name):
-            if os.path.isfile(fname):
-                os.unlink(fname)
-
-    def testCopy(self):
-        s = (0, FO_COPY, self.src_name, self.dest_name)  # hwnd,  # operation
-
-        rc, aborted = shell.SHFileOperation(s)
-        self.assertTrue(not aborted)
-        self.assertEqual(0, rc)
-        self.assertTrue(os.path.isfile(self.src_name))
-        self.assertTrue(os.path.isfile(self.dest_name))
-
-    def testRename(self):
-        s = (0, FO_RENAME, self.src_name, self.dest_name)  # hwnd,  # operation
-        rc, aborted = shell.SHFileOperation(s)
-        self.assertTrue(not aborted)
-        self.assertEqual(0, rc)
-        self.assertTrue(os.path.isfile(self.dest_name))
-        self.assertTrue(not os.path.isfile(self.src_name))
-
-    def testMove(self):
-        s = (0, FO_MOVE, self.src_name, self.dest_name)  # hwnd,  # operation
-        rc, aborted = shell.SHFileOperation(s)
-        self.assertTrue(not aborted)
-        self.assertEqual(0, rc)
-        self.assertTrue(os.path.isfile(self.dest_name))
-        self.assertTrue(not os.path.isfile(self.src_name))
-
-    def testDelete(self):
-        s = (
-            0,  # hwnd,
-            FO_DELETE,  # operation
-            self.src_name,
-            None,
-            FOF_NOCONFIRMATION,
-        )
-        rc, aborted = shell.SHFileOperation(s)
-        self.assertTrue(not aborted)
-        self.assertEqual(0, rc)
-        self.assertTrue(not os.path.isfile(self.src_name))
-
-
-if __name__ == "__main__":
-    win32com.test.util.testmain()

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

@@ -1,88 +0,0 @@
-import unittest
-
-import pythoncom
-import win32api
-import win32com.test.util
-from win32com import storagecon
-
-
-class TestEnum(win32com.test.util.TestCase):
-    def testit(self):
-        fname, tmp = win32api.GetTempFileName(win32api.GetTempPath(), "stg")
-        m = storagecon.STGM_READWRITE | storagecon.STGM_SHARE_EXCLUSIVE
-        ##  file, mode, format, attrs (always 0), IID (IStorage or IPropertySetStorage, storage options(only used with STGFMT_DOCFILE)
-        pss = pythoncom.StgOpenStorageEx(
-            fname, m, storagecon.STGFMT_FILE, 0, pythoncom.IID_IPropertySetStorage
-        )
-        ###                               {"Version":2,"reserved":0,"SectorSize":512,"TemplateFile":'somefilename'})
-
-        ## FMTID_SummaryInformation FMTID_DocSummaryInformation FMTID_UserDefinedProperties
-        psuser = pss.Create(
-            pythoncom.FMTID_UserDefinedProperties,
-            pythoncom.IID_IPropertySetStorage,
-            storagecon.PROPSETFLAG_DEFAULT,
-            storagecon.STGM_READWRITE
-            | storagecon.STGM_CREATE
-            | storagecon.STGM_SHARE_EXCLUSIVE,
-        )  ## it's very picky about flag combinations!
-        psuser.WriteMultiple((3, 4), ("hey", "bubba"))
-        psuser.WritePropertyNames((3, 4), ("property3", "property4"))
-        expected_summaries = []
-        expected_summaries.append(("property3", 3, pythoncom.VT_BSTR))
-        expected_summaries.append(("property4", 4, pythoncom.VT_BSTR))
-        psuser = None
-
-        pssum = pss.Create(
-            pythoncom.FMTID_SummaryInformation,
-            pythoncom.IID_IPropertySetStorage,
-            storagecon.PROPSETFLAG_DEFAULT,
-            storagecon.STGM_READWRITE
-            | storagecon.STGM_CREATE
-            | storagecon.STGM_SHARE_EXCLUSIVE,
-        )
-        pssum.WriteMultiple(
-            (storagecon.PIDSI_AUTHOR, storagecon.PIDSI_COMMENTS), ("me", "comment")
-        )
-
-        pssum = None
-        pss = None  ## doesn't seem to be a close or release method, and you can't even reopen it from the same process until previous object is gone
-
-        pssread = pythoncom.StgOpenStorageEx(
-            fname,
-            storagecon.STGM_READ | storagecon.STGM_SHARE_EXCLUSIVE,
-            storagecon.STGFMT_FILE,
-            0,
-            pythoncom.IID_IPropertySetStorage,
-        )
-        found_summaries = []
-        for psstat in pssread:
-            ps = pssread.Open(
-                psstat[0], storagecon.STGM_READ | storagecon.STGM_SHARE_EXCLUSIVE
-            )
-            for p in ps:
-                p_val = ps.ReadMultiple((p[1],))[0]
-                if (p[1] == storagecon.PIDSI_AUTHOR and p_val == "me") or (
-                    p[1] == storagecon.PIDSI_COMMENTS and p_val == "comment"
-                ):
-                    pass
-                else:
-                    self.fail(f"Uxexpected property {p}/{p_val}")
-            ps = None
-            ## FMTID_UserDefinedProperties can't exist without FMTID_DocSummaryInformation, and isn't returned independently from Enum
-            ## also can't be open at same time
-            if psstat[0] == pythoncom.FMTID_DocSummaryInformation:
-                ps = pssread.Open(
-                    pythoncom.FMTID_UserDefinedProperties,
-                    storagecon.STGM_READ | storagecon.STGM_SHARE_EXCLUSIVE,
-                )
-                for p in ps:
-                    found_summaries.append(p)
-                ps = None
-        psread = None
-        expected_summaries.sort()
-        found_summaries.sort()
-        self.assertEqual(expected_summaries, found_summaries)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,147 +0,0 @@
-import unittest
-
-import pythoncom
-import win32com.server.util
-import win32com.test.util
-
-
-class Persists:
-    _public_methods_ = [
-        "GetClassID",
-        "IsDirty",
-        "Load",
-        "Save",
-        "GetSizeMax",
-        "InitNew",
-    ]
-    _com_interfaces_ = [pythoncom.IID_IPersistStreamInit]
-
-    def __init__(self):
-        self.data = b"abcdefg"
-        self.dirty = 1
-
-    def GetClassID(self):
-        return pythoncom.IID_NULL
-
-    def IsDirty(self):
-        return self.dirty
-
-    def Load(self, stream):
-        self.data = stream.Read(26)
-
-    def Save(self, stream, clearDirty):
-        stream.Write(self.data)
-        if clearDirty:
-            self.dirty = 0
-
-    def GetSizeMax(self):
-        return 1024
-
-    def InitNew(self):
-        pass
-
-
-class Stream:
-    _public_methods_ = ["Read", "Write", "Seek"]
-    _com_interfaces_ = [pythoncom.IID_IStream]
-
-    def __init__(self, data):
-        self.data = data
-        self.index = 0
-
-    def Read(self, amount):
-        result = self.data[self.index : self.index + amount]
-        self.index += amount
-        return result
-
-    def Write(self, data):
-        self.data = data
-        self.index = 0
-        return len(data)
-
-    def Seek(self, dist, origin):
-        if origin == pythoncom.STREAM_SEEK_SET:
-            self.index = dist
-        elif origin == pythoncom.STREAM_SEEK_CUR:
-            self.index += dist
-        elif origin == pythoncom.STREAM_SEEK_END:
-            self.index = len(self.data) + dist
-        else:
-            raise ValueError("Unknown Seek type: " + str(origin))
-        if self.index < 0:
-            self.index = 0
-        else:
-            self.index = min(self.index, len(self.data))
-        return self.index
-
-
-class BadStream(Stream):
-    """PyGStream::Read could formerly overflow buffer if the python implementation
-    returned more data than requested.
-    """
-
-    def Read(self, amount):
-        return b"x" * (amount + 1)
-
-
-class StreamTest(win32com.test.util.TestCase):
-    def _readWrite(self, data, write_stream, read_stream=None):
-        if read_stream is None:
-            read_stream = write_stream
-        write_stream.Write(data)
-        read_stream.Seek(0, pythoncom.STREAM_SEEK_SET)
-        got = read_stream.Read(len(data))
-        self.assertEqual(data, got)
-        read_stream.Seek(1, pythoncom.STREAM_SEEK_SET)
-        got = read_stream.Read(len(data) - 2)
-        self.assertEqual(data[1:-1], got)
-
-    def testit(self):
-        mydata = b"abcdefghijklmnopqrstuvwxyz"
-
-        # First test the objects just as Python objects...
-        s = Stream(mydata)
-        p = Persists()
-
-        p.Load(s)
-        p.Save(s, 0)
-        self.assertEqual(s.data, mydata)
-
-        # Wrap the Python objects as COM objects, and make the calls as if
-        # they were non-Python COM objects.
-        s2 = win32com.server.util.wrap(s, pythoncom.IID_IStream)
-        p2 = win32com.server.util.wrap(p, pythoncom.IID_IPersistStreamInit)
-
-        self._readWrite(mydata, s, s)
-        self._readWrite(mydata, s, s2)
-        self._readWrite(mydata, s2, s)
-        self._readWrite(mydata, s2, s2)
-
-        self._readWrite(b"string with\0a NULL", s2, s2)
-        # reset the stream
-        s.Write(mydata)
-        p2.Load(s2)
-        p2.Save(s2, 0)
-        self.assertEqual(s.data, mydata)
-
-    def testseek(self):
-        s = Stream(b"yo")
-        s = win32com.server.util.wrap(s, pythoncom.IID_IStream)
-        # we used to die passing a value > 32bits
-        s.Seek(0x100000000, pythoncom.STREAM_SEEK_SET)
-
-    def testerrors(self):
-        # setup a test logger to capture tracebacks etc.
-        records, old_log = win32com.test.util.setup_test_logger()
-        ## check for buffer overflow in Read method
-        badstream = BadStream("Check for buffer overflow")
-        badstream2 = win32com.server.util.wrap(badstream, pythoncom.IID_IStream)
-        self.assertRaises(pythoncom.com_error, badstream2.Read, 10)
-        win32com.test.util.restore_test_logger(old_log)
-        # there's 1 error here
-        self.assertEqual(len(records), 1)
-        self.assertTrue(records[0].msg.startswith("pythoncom error"))
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,18 +0,0 @@
-import unittest
-
-import win32com.test.util
-from win32com.client import GetObject
-
-
-class Simple(win32com.test.util.TestCase):
-    def testit(self):
-        cses = GetObject("WinMgMts:").InstancesOf("Win32_Process")
-        vals = []
-        for cs in cses:
-            val = cs.Properties_("Caption").Value
-            vals.append(val)
-        self.assertFalse(len(vals) < 5, "We only found %d processes!" % len(vals))
-
-
-if __name__ == "__main__":
-    unittest.main()