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

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32gui.py

@@ -1,227 +0,0 @@
-# tests for win32gui
-import array
-import operator
-import sys
-import unittest
-
-import pywintypes
-import win32api
-import win32gui
-
-
-class TestPyGetString(unittest.TestCase):
-    def test_get_string(self):
-        # test invalid addresses cause a ValueError rather than crash!
-        self.assertRaises(ValueError, win32gui.PyGetString, 0)
-        self.assertRaises(ValueError, win32gui.PyGetString, 1)
-        self.assertRaises(ValueError, win32gui.PyGetString, 1, 1)
-
-
-class TestPyGetMemory(unittest.TestCase):
-    def test_ob(self):
-        # Check the PyGetMemory result and a bytes string can be compared
-        test_data = b"\0\1\2\3\4\5\6"
-        c = array.array("b", test_data)
-        addr, buflen = c.buffer_info()
-        got = win32gui.PyGetMemory(addr, buflen)
-        self.assertEqual(len(got), len(test_data))
-        self.assertEqual(bytes(got), test_data)
-
-    def test_memory_index(self):
-        # Check we can index into the buffer object returned by PyGetMemory
-        test_data = b"\0\1\2\3\4\5\6"
-        c = array.array("b", test_data)
-        addr, buflen = c.buffer_info()
-        got = win32gui.PyGetMemory(addr, buflen)
-        self.assertEqual(got[0], 0)
-
-    def test_memory_slice(self):
-        # Check we can slice the buffer object returned by PyGetMemory
-        test_data = b"\0\1\2\3\4\5\6"
-        c = array.array("b", test_data)
-        addr, buflen = c.buffer_info()
-        got = win32gui.PyGetMemory(addr, buflen)
-        self.assertEqual(list(got[0:3]), [0, 1, 2])
-
-    def test_real_view(self):
-        # Do the PyGetMemory, then change the original memory, then ensure
-        # the initial object we fetched sees the new value.
-        test_data = b"\0\1\2\3\4\5\6"
-        c = array.array("b", test_data)
-        addr, buflen = c.buffer_info()
-        got = win32gui.PyGetMemory(addr, buflen)
-        self.assertEqual(got[0], 0)
-        c[0] = 1
-        self.assertEqual(got[0], 1)
-
-    def test_memory_not_writable(self):
-        # Check the buffer object fetched by PyGetMemory isn't writable.
-        test_data = b"\0\1\2\3\4\5\6"
-        c = array.array("b", test_data)
-        addr, buflen = c.buffer_info()
-        got = win32gui.PyGetMemory(addr, buflen)
-        self.assertRaises(TypeError, operator.setitem, got, 0, 1)
-
-
-class TestEnumWindowsFamily(unittest.TestCase):
-    @classmethod
-    def enum_callback_sle(cls, handle, data):
-        win32api.SetLastError(1)
-        return data
-
-    @classmethod
-    def enum_callback_exc(cls, handle, data):
-        raise ValueError
-
-    @classmethod
-    def enum_callback(cls, handle, data):
-        return data
-
-    def setUp(self):
-        self.default_data_set = (None, -1, 0, 1, True, False)
-        self.type_data_set = ("", (), {})
-
-    def test_enumwindows(self):
-        win32api.SetLastError(0)
-        for data in (0, False):
-            self.assertRaises(
-                pywintypes.error, win32gui.EnumWindows, self.enum_callback_sle, data
-            )
-        for data in (None, 1, True):
-            self.assertIsNone(win32gui.EnumWindows(self.enum_callback_sle, data))
-        win32api.SetLastError(0)
-        for data in self.default_data_set:
-            self.assertIsNone(win32gui.EnumWindows(self.enum_callback, data))
-        for data in self.default_data_set:
-            self.assertRaises(
-                ValueError, win32gui.EnumWindows, self.enum_callback_exc, data
-            )
-        for func in (
-            self.enum_callback,
-            self.enum_callback_sle,
-        ):
-            for data in self.type_data_set:
-                self.assertRaises(TypeError, win32gui.EnumWindows, func, data)
-        if sys.version_info >= (3, 10):
-            for func in (
-                self.enum_callback,
-                self.enum_callback_sle,
-            ):
-                self.assertRaises(
-                    TypeError, win32gui.EnumWindows, func, self.enum_callback, 2.718282
-                )
-
-    def test_enumchildwindows(self):
-        win32api.SetLastError(0)
-        for data in self.default_data_set:
-            self.assertIsNone(win32gui.EnumChildWindows(None, self.enum_callback, data))
-        for data in self.default_data_set:
-            self.assertIsNone(
-                win32gui.EnumChildWindows(None, self.enum_callback_sle, data)
-            )
-        win32api.SetLastError(0)
-        for data in self.default_data_set:
-            self.assertRaises(
-                ValueError,
-                win32gui.EnumChildWindows,
-                None,
-                self.enum_callback_exc,
-                data,
-            )
-        for data in self.type_data_set:
-            for func in (
-                self.enum_callback,
-                self.enum_callback_sle,
-            ):
-                self.assertRaises(
-                    TypeError, win32gui.EnumChildWindows, None, func, data
-                )
-        if sys.version_info >= (3, 10):
-            for func in (
-                self.enum_callback,
-                self.enum_callback_sle,
-            ):
-                self.assertRaises(
-                    TypeError,
-                    win32gui.EnumChildWindows,
-                    None,
-                    func,
-                    self.enum_callback,
-                    2.718282,
-                )
-
-    def test_enumdesktopwindows(self):
-        win32api.SetLastError(0)
-        desktop = None
-        for data in (0, False):
-            self.assertRaises(
-                pywintypes.error,
-                win32gui.EnumDesktopWindows,
-                desktop,
-                self.enum_callback_sle,
-                data,
-            )
-        for data in (None, 1, True):
-            self.assertIsNone(
-                win32gui.EnumDesktopWindows(desktop, self.enum_callback_sle, data)
-            )
-        win32api.SetLastError(0)
-        for data in self.default_data_set:
-            self.assertIsNone(
-                win32gui.EnumDesktopWindows(desktop, self.enum_callback, data)
-            )
-        for data in self.default_data_set:
-            self.assertRaises(
-                ValueError,
-                win32gui.EnumDesktopWindows,
-                desktop,
-                self.enum_callback_exc,
-                data,
-            )
-        desktops = (0, None)
-        for desktop in desktops:
-            for data in self.default_data_set:
-                self.assertRaises(
-                    ValueError,
-                    win32gui.EnumDesktopWindows,
-                    desktop,
-                    self.enum_callback_exc,
-                    data,
-                )
-        for func in (
-            self.enum_callback,
-            self.enum_callback_sle,
-        ):
-            for desktop in desktops:
-                for data in self.type_data_set:
-                    self.assertRaises(
-                        TypeError, win32gui.EnumDesktopWindows, 0, func, data
-                    )
-        if sys.version_info >= (3, 10):
-            for func in (
-                self.enum_callback,
-                self.enum_callback_sle,
-            ):
-                for desktop in desktops:
-                    self.assertRaises(
-                        TypeError, win32gui.EnumDesktopWindows, 0, func, 2.718282
-                    )
-
-
-class TestWindowProperties(unittest.TestCase):
-    def setUp(self):
-        self.class_functions = (
-            win32gui.GetClassName,
-            win32gui.RealGetWindowClass,
-        )
-
-    def test_classname(self):
-        for func in self.class_functions:
-            self.assertRaises(pywintypes.error, func, 0)
-        wnd = win32gui.GetDesktopWindow()
-        for func in self.class_functions:
-            self.assertTrue(func(wnd))
-
-
-if __name__ == "__main__":
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32guistruct.py

@@ -1,333 +0,0 @@
-import array
-import unittest
-
-import pythoncom
-import win32con
-import win32gui_struct
-
-
-class TestBase(unittest.TestCase):
-    def assertDictEquals(self, d, **kw):
-        checked = {}
-        for n, v in kw.items():
-            self.assertEqual(v, d[n], f"'{n}' doesn't match: {v!r} != {d[n]!r}")
-            checked[n] = True
-        checked_keys = sorted(checked)
-        passed_keys = sorted(kw)
-        self.assertEqual(checked_keys, passed_keys)
-
-
-class TestMenuItemInfo(TestBase):
-    def _testPackUnpack(self, text):
-        vals = {
-            "fType": win32con.MFT_MENUBARBREAK,
-            "fState": win32con.MFS_CHECKED,
-            "wID": 123,
-            "hSubMenu": 1234,
-            "hbmpChecked": 12345,
-            "hbmpUnchecked": 123456,
-            "dwItemData": 1234567,
-            "text": text,
-            "hbmpItem": 321,
-        }
-        mii, extras = win32gui_struct.PackMENUITEMINFO(**vals)
-        (
-            fType,
-            fState,
-            wID,
-            hSubMenu,
-            hbmpChecked,
-            hbmpUnchecked,
-            dwItemData,
-            text,
-            hbmpItem,
-        ) = win32gui_struct.UnpackMENUITEMINFO(mii)
-        self.assertDictEquals(
-            vals,
-            fType=fType,
-            fState=fState,
-            wID=wID,
-            hSubMenu=hSubMenu,
-            hbmpChecked=hbmpChecked,
-            hbmpUnchecked=hbmpUnchecked,
-            dwItemData=dwItemData,
-            text=text,
-            hbmpItem=hbmpItem,
-        )
-
-    def testPackUnpack(self):
-        self._testPackUnpack("Hello")
-
-    def testPackUnpackNone(self):
-        self._testPackUnpack(None)
-
-    def testEmptyMenuItemInfo(self):
-        mii, extra = win32gui_struct.EmptyMENUITEMINFO()
-        (
-            fType,
-            fState,
-            wID,
-            hSubMenu,
-            hbmpChecked,
-            hbmpUnchecked,
-            dwItemData,
-            text,
-            hbmpItem,
-        ) = win32gui_struct.UnpackMENUITEMINFO(mii)
-        self.assertEqual(fType, 0)
-        self.assertEqual(fState, 0)
-        self.assertEqual(wID, 0)
-        self.assertEqual(hSubMenu, 0)
-        self.assertEqual(hbmpChecked, 0)
-        self.assertEqual(hbmpUnchecked, 0)
-        self.assertEqual(dwItemData, 0)
-        self.assertEqual(hbmpItem, 0)
-        # it's not clear if UnpackMENUITEMINFO() should ignore cch, instead
-        # assuming it is a buffer size rather than 'current length' - but it
-        # never has (and this gives us every \0 in the string), and actually
-        # helps us test the unicode/str semantics.
-        self.assertEqual(text, "\0" * len(text))
-
-
-class TestMenuInfo(TestBase):
-    def testPackUnpack(self):
-        vals = {
-            "dwStyle": 1,
-            "cyMax": 2,
-            "hbrBack": 3,
-            "dwContextHelpID": 4,
-            "dwMenuData": 5,
-        }
-
-        mi = win32gui_struct.PackMENUINFO(**vals)
-        (
-            dwStyle,
-            cyMax,
-            hbrBack,
-            dwContextHelpID,
-            dwMenuData,
-        ) = win32gui_struct.UnpackMENUINFO(mi)
-
-        self.assertDictEquals(
-            vals,
-            dwStyle=dwStyle,
-            cyMax=cyMax,
-            hbrBack=hbrBack,
-            dwContextHelpID=dwContextHelpID,
-            dwMenuData=dwMenuData,
-        )
-
-    def testEmptyMenuItemInfo(self):
-        mi = win32gui_struct.EmptyMENUINFO()
-        (
-            dwStyle,
-            cyMax,
-            hbrBack,
-            dwContextHelpID,
-            dwMenuData,
-        ) = win32gui_struct.UnpackMENUINFO(mi)
-        self.assertEqual(dwStyle, 0)
-        self.assertEqual(cyMax, 0)
-        self.assertEqual(hbrBack, 0)
-        self.assertEqual(dwContextHelpID, 0)
-        self.assertEqual(dwMenuData, 0)
-
-
-class TestTreeViewItem(TestBase):
-    def _testPackUnpack(self, text):
-        vals = {
-            "hitem": 1,
-            "state": 2,
-            "stateMask": 3,
-            "text": text,
-            "image": 4,
-            "selimage": 5,
-            "citems": 6,
-            "param": 7,
-        }
-
-        ti, extra = win32gui_struct.PackTVITEM(**vals)
-        (
-            hitem,
-            state,
-            stateMask,
-            text,
-            image,
-            selimage,
-            citems,
-            param,
-        ) = win32gui_struct.UnpackTVITEM(ti)
-
-        self.assertDictEquals(
-            vals,
-            hitem=hitem,
-            state=state,
-            stateMask=stateMask,
-            text=text,
-            image=image,
-            selimage=selimage,
-            citems=citems,
-            param=param,
-        )
-
-    def testPackUnpack(self):
-        self._testPackUnpack("Hello")
-
-    def testPackUnpackNone(self):
-        self._testPackUnpack(None)
-
-    def testEmpty(self):
-        ti, extras = win32gui_struct.EmptyTVITEM(0)
-        (
-            hitem,
-            state,
-            stateMask,
-            text,
-            image,
-            selimage,
-            citems,
-            param,
-        ) = win32gui_struct.UnpackTVITEM(ti)
-        self.assertEqual(hitem, 0)
-        self.assertEqual(state, 0)
-        self.assertEqual(stateMask, 0)
-        self.assertEqual(text, "")
-        self.assertEqual(image, 0)
-        self.assertEqual(selimage, 0)
-        self.assertEqual(citems, 0)
-        self.assertEqual(param, 0)
-
-
-class TestListViewItem(TestBase):
-    def _testPackUnpack(self, text):
-        vals = {
-            "item": None,
-            "subItem": None,
-            "state": 1,
-            "stateMask": 2,
-            "text": text,
-            "image": 3,
-            "param": 4,
-            "indent": 5,
-        }
-
-        ti, extra = win32gui_struct.PackLVITEM(**vals)
-        (
-            item,
-            subItem,
-            state,
-            stateMask,
-            text,
-            image,
-            param,
-            indent,
-        ) = win32gui_struct.UnpackLVITEM(ti)
-
-        # patch expected values.
-        vals["item"] = 0
-        vals["subItem"] = 0
-        self.assertDictEquals(
-            vals,
-            item=item,
-            subItem=subItem,
-            state=state,
-            stateMask=stateMask,
-            text=text,
-            image=image,
-            param=param,
-            indent=indent,
-        )
-
-    def testPackUnpack(self):
-        self._testPackUnpack("Hello")
-
-    def testPackUnpackNone(self):
-        self._testPackUnpack(None)
-
-    def testEmpty(self):
-        ti, extras = win32gui_struct.EmptyLVITEM(1, 2)
-        (
-            item,
-            subItem,
-            state,
-            stateMask,
-            text,
-            image,
-            param,
-            indent,
-        ) = win32gui_struct.UnpackLVITEM(ti)
-        self.assertEqual(item, 1)
-        self.assertEqual(subItem, 2)
-        self.assertEqual(state, 0)
-        self.assertEqual(stateMask, 0)
-        self.assertEqual(text, "")
-        self.assertEqual(image, 0)
-        self.assertEqual(param, 0)
-        self.assertEqual(indent, 0)
-
-
-class TestLVColumn(TestBase):
-    def _testPackUnpack(self, text):
-        vals = {"fmt": 1, "cx": 2, "text": text, "subItem": 3, "image": 4, "order": 5}
-
-        ti, extra = win32gui_struct.PackLVCOLUMN(**vals)
-        fmt, cx, text, subItem, image, order = win32gui_struct.UnpackLVCOLUMN(ti)
-
-        self.assertDictEquals(
-            vals, fmt=fmt, cx=cx, text=text, subItem=subItem, image=image, order=order
-        )
-
-    def testPackUnpack(self):
-        self._testPackUnpack("Hello")
-
-    def testPackUnpackNone(self):
-        self._testPackUnpack(None)
-
-    def testEmpty(self):
-        ti, extras = win32gui_struct.EmptyLVCOLUMN()
-        fmt, cx, text, subItem, image, order = win32gui_struct.UnpackLVCOLUMN(ti)
-        self.assertEqual(fmt, 0)
-        self.assertEqual(cx, 0)
-        self.assertEqual(text, "")
-        self.assertEqual(subItem, 0)
-        self.assertEqual(image, 0)
-        self.assertEqual(order, 0)
-
-
-class TestDEV_BROADCAST_HANDLE(TestBase):
-    def testPackUnpack(self):
-        s = win32gui_struct.PackDEV_BROADCAST_HANDLE(123)
-        c = array.array("b", s)
-        got = win32gui_struct.UnpackDEV_BROADCAST(c.buffer_info()[0])
-        self.assertEqual(got.handle, 123)
-
-    def testGUID(self):
-        s = win32gui_struct.PackDEV_BROADCAST_HANDLE(123, guid=pythoncom.IID_IUnknown)
-        c = array.array("b", s)
-        got = win32gui_struct.UnpackDEV_BROADCAST(c.buffer_info()[0])
-        self.assertEqual(got.handle, 123)
-        self.assertEqual(got.eventguid, pythoncom.IID_IUnknown)
-
-
-class TestDEV_BROADCAST_DEVICEINTERFACE(TestBase):
-    def testPackUnpack(self):
-        s = win32gui_struct.PackDEV_BROADCAST_DEVICEINTERFACE(
-            pythoncom.IID_IUnknown, "hello"
-        )
-        c = array.array("b", s)
-        got = win32gui_struct.UnpackDEV_BROADCAST(c.buffer_info()[0])
-        self.assertEqual(got.classguid, pythoncom.IID_IUnknown)
-        self.assertEqual(got.name, "hello")
-
-
-class TestDEV_BROADCAST_VOLUME(TestBase):
-    def testPackUnpack(self):
-        s = win32gui_struct.PackDEV_BROADCAST_VOLUME(123, 456)
-        c = array.array("b", s)
-        got = win32gui_struct.UnpackDEV_BROADCAST(c.buffer_info()[0])
-        self.assertEqual(got.unitmask, 123)
-        self.assertEqual(got.flags, 456)
-
-
-if __name__ == "__main__":
-    unittest.main()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32inet.py

@@ -1,108 +0,0 @@
-import unittest
-
-import winerror
-from pywin32_testutil import TestSkipped, testmain
-from win32inet import (
-    FtpCommand,
-    InternetCanonicalizeUrl,
-    InternetConnect,
-    InternetGetCookie,
-    InternetGetLastResponseInfo,
-    InternetOpen,
-    InternetOpenUrl,
-    InternetReadFile,
-    InternetSetCookie,
-    error,
-)
-from win32inetcon import (
-    FTP_TRANSFER_TYPE_ASCII,
-    INTERNET_FLAG_EXISTING_CONNECT,
-    INTERNET_INVALID_PORT_NUMBER,
-    INTERNET_OPEN_TYPE_DIRECT,
-    INTERNET_SERVICE_FTP,
-)
-
-
-class CookieTests(unittest.TestCase):
-    def testCookies(self):
-        data = "TestData=Test"
-        InternetSetCookie("https://www.python.org", None, data)
-        got = InternetGetCookie("https://www.python.org", None)
-        # handle that there might already be cookies for the domain.
-        bits = (x.strip() for x in got.split(";"))
-        self.assertTrue(data in bits)
-
-    def testCookiesEmpty(self):
-        try:
-            InternetGetCookie("https://site-with-no-cookie.python.org", None)
-            self.fail("expected win32 exception")
-        except error as exc:
-            self.assertEqual(exc.winerror, winerror.ERROR_NO_MORE_ITEMS)
-
-
-class UrlTests(unittest.TestCase):
-    def testSimpleCanonicalize(self):
-        ret = InternetCanonicalizeUrl("foo bar")
-        self.assertEqual(ret, "foo%20bar")
-
-    def testLongCanonicalize(self):
-        # a 4k URL causes the underlying API to request a bigger buffer"
-        big = "x" * 2048
-        ret = InternetCanonicalizeUrl(big + " " + big)
-        self.assertEqual(ret, big + "%20" + big)
-
-
-class TestNetwork(unittest.TestCase):
-    def setUp(self):
-        self.hi = InternetOpen("test", INTERNET_OPEN_TYPE_DIRECT, None, None, 0)
-
-    def tearDown(self):
-        self.hi.Close()
-
-    def testPythonDotOrg(self):
-        hdl = InternetOpenUrl(
-            self.hi, "https://www.python.org", None, INTERNET_FLAG_EXISTING_CONNECT
-        )
-        chunks = []
-        while 1:
-            chunk = InternetReadFile(hdl, 1024)
-            if not chunk:
-                break
-            chunks.append(chunk)
-        data = b"".join(chunks)
-        # This must appear somewhere on the main page!
-        self.assertGreater(data.find(b"Python"), 0, repr(data))
-
-    def testFtpCommand(self):
-        # ftp.python.org doesn't exist.  ftp.gnu.org is what Python's urllib
-        # test code uses.
-        # (As of 2020 it doesn't! Unsurprisingly, it's difficult to find a good
-        # test server. This test sometimes works, but often doesn't - so handle
-        # failure here as a "skip")
-        try:
-            hcon = InternetConnect(
-                self.hi,
-                "ftp.gnu.org",
-                INTERNET_INVALID_PORT_NUMBER,
-                None,
-                None,  # username/password
-                INTERNET_SERVICE_FTP,
-                0,
-                0,
-            )
-            try:
-                hftp = FtpCommand(hcon, True, FTP_TRANSFER_TYPE_ASCII, "NLST", 0)
-                try:
-                    print("Connected - response info is", InternetGetLastResponseInfo())
-                    got = InternetReadFile(hftp, 2048)
-                    print("Read", len(got), "bytes")
-                finally:
-                    hftp.Close()
-            finally:
-                hcon.Close()
-        except error as e:
-            raise TestSkipped(e)
-
-
-if __name__ == "__main__":
-    testmain()

py2docfx/venv/venv1/Lib/site-packages/win32/test/test_win32net.py

@@ -1,23 +0,0 @@
-import unittest
-
-import win32net
-
-
-class TestCase(unittest.TestCase):
-    def testGroupsGoodResume(self, server=None):
-        res = 0
-        level = 0  # setting it to 1 will provide more detailed info
-        while True:
-            (user_list, total, res) = win32net.NetGroupEnum(server, level, res)
-            for i in user_list:
-                pass
-            if not res:
-                break
-
-    def testGroupsBadResume(self, server=None):
-        res = 1  # Can't pass this first time round.
-        self.assertRaises(win32net.error, win32net.NetGroupEnum, server, 0, res)
-
-
-if __name__ == "__main__":
-    unittest.main()