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

py2docfx/venv/venv1/Lib/site-packages/win32/scripts/setup_d.py

@@ -1,111 +0,0 @@
-# Install and register pythonXX_d.dll, pywintypesXX_d.dll and pythoncomXX_d.dll
-#
-# Assumes the _d files can be found in the same directory as this script
-# or in the cwd.
-
-import os
-import shutil
-import sys
-import winreg
-
-import win32api
-
-
-def usage_and_die(rc):
-    print()
-    print("This script is designed to copy and register the Python debug")
-    print("binaries.  It looks for pythonXX_d.dll, pythoncomXX_d.dll etc,")
-    print("and installs them to work correctly with Python debug builds.")
-    print()
-    print("You will generally find this script in the. zip file that")
-    print("included these _d files.  Please run this script from")
-    print("that directory")
-    sys.exit(rc)
-
-
-if os.path.splitext(os.path.basename(win32api.__file__))[0].endswith("_d"):
-    print("This scripts appears to be running a DEBUG version of Python.")
-    print("Please run it using a normal release build (python.exe)")
-    usage_and_die(1)
-
-try:
-    import pythoncom
-except ImportError as details:
-    print("Could not import the release version of pythoncom")
-    print(f"The error details are: {details}")
-    print("Please correct this error and rerun the script")
-    usage_and_die(2)
-
-try:
-    import pywintypes
-except ImportError as details:
-    print("Could not import the release version of pywintypes")
-    print(f"The error details are: {details}")
-    print("Please correct this error and rerun the script")
-    usage_and_die(2)
-
-
-def _docopy(src, dest):
-    orig_src = src
-    if not os.path.isfile(src):
-        src = os.path.join(os.path.split(sys.argv[0])[0], src)
-        print(
-            "Can not find {} or {} to copy".format(
-                os.path.abspath(orig_src), os.path.abspath(src)
-            )
-        )
-        return 0
-    try:
-        shutil.copy(src, dest)
-        print(f"Copied {src} -> {dest}")
-        return 1
-    except:
-        print(f"Error copying '{src}' -> '{dest}'")
-        print(sys.exc_info()[1])
-        usage_and_die(3)
-
-
-def _doregister(mod_name, dll_name):
-    assert os.path.isfile(dll_name), "Shouldn't get here if the file doesn't exist!"
-    try:
-        key = winreg.OpenKey(
-            winreg.HKEY_LOCAL_MACHINE,
-            f"Software\\Python\\PythonCore\\{sys.winver}\\Modules\\{mod_name}",
-        )
-    except winreg.error:
-        try:
-            key = winreg.OpenKey(
-                winreg.HKEY_LOCAL_MACHINE,
-                f"Software\\Python\\PythonCore\\{sys.winver}\\Modules\\{mod_name}",
-            )
-        except winreg.error:
-            print(
-                "Could not find the existing '{}' module registered in the registry".format(
-                    mod_name
-                )
-            )
-            usage_and_die(4)
-    # Create the debug key.
-    sub_key = winreg.CreateKey(key, "Debug")
-    winreg.SetValue(sub_key, None, winreg.REG_SZ, dll_name)
-    print(f"Registered '{dll_name}' in the registry")
-
-
-def _domodule(mod_name, release_mod_filename):
-    path, fname = os.path.split(release_mod_filename)
-    base, ext = os.path.splitext(fname)
-    new_fname = base + "_d" + ext
-    if _docopy(new_fname, path):
-        _doregister(mod_name, os.path.abspath(os.path.join(path, new_fname)))
-
-
-# First the main Python DLL.
-path, fname = path, fname = os.path.split(win32api.GetModuleFileName(sys.dllhandle))
-base, ext = os.path.splitext(fname)
-_docopy(base + "_d" + ext, path)
-
-# Then pythoncom and pywintypes.
-_domodule("pythoncom", pythoncom.__file__)
-_domodule("pywintypes", pywintypes.__file__)
-
-print("System _d files were setup.")

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

@@ -1,175 +0,0 @@
-import sys
-import unittest
-
-import pywintypes
-import win32api
-
-
-class TestError1(Exception):
-    pass
-
-
-class TestError2(Exception):
-    pass
-
-
-# A class that will never die vie refcounting, but will die via GC.
-class Cycle:
-    def __init__(self, handle):
-        self.cycle = self
-        self.handle = handle
-
-
-class PyHandleTestCase(unittest.TestCase):
-    def testCleanup1(self):
-        # We used to clobber all outstanding exceptions.
-        def f1(invalidate):
-            import win32event
-
-            h = win32event.CreateEvent(None, 0, 0, None)
-            if invalidate:
-                win32api.CloseHandle(int(h))
-            raise TestError1
-            # If we invalidated, then the object destruction code will attempt
-            # to close an invalid handle.  We don't wan't an exception in
-            # this case
-
-        def f2(invalidate):
-            """This function should throw an OSError."""
-            try:
-                f1(invalidate)
-            except TestError1:
-                raise TestError2
-
-        self.assertRaises(TestError2, f2, False)
-        # Now do it again, but so the auto object destruction
-        # actually fails.
-        self.assertRaises(TestError2, f2, True)
-
-    def testCleanup2(self):
-        # Cause an exception during object destruction.
-        # The worst this does is cause an ".XXX undetected error (why=3)"
-        # So avoiding that is the goal
-        import win32event
-
-        h = win32event.CreateEvent(None, 0, 0, None)
-        # Close the handle underneath the object.
-        win32api.CloseHandle(int(h))
-        # Object destructor runs with the implicit close failing
-        h = None
-
-    def testCleanup3(self):
-        # And again with a class - no __del__
-        import win32event
-
-        class Test:
-            def __init__(self):
-                self.h = win32event.CreateEvent(None, 0, 0, None)
-                win32api.CloseHandle(int(self.h))
-
-        t = Test()
-        t = None
-
-    def testCleanupGood(self):
-        # And check that normal error semantics *do* work.
-        import win32event
-
-        h = win32event.CreateEvent(None, 0, 0, None)
-        win32api.CloseHandle(int(h))
-        self.assertRaises(win32api.error, h.Close)
-        # A following Close is documented as working
-        h.Close()
-
-    def testInvalid(self):
-        h = pywintypes.HANDLE(-2)
-        try:
-            h.Close()
-            # Ideally, we'd:
-            #     self.assertRaises(win32api.error, h.Close)
-            # and everywhere markh has tried, that would pass - but not on
-            # github automation, where the .Close apparently works fine.
-            # (same for -1. Using 0 appears to work fine everywhere)
-            # There still seems value in testing it though, so we just accept
-            # either working or failing.
-        except win32api.error:
-            pass
-
-    def testOtherHandle(self):
-        h = pywintypes.HANDLE(1)
-        h2 = pywintypes.HANDLE(h)
-        self.assertEqual(h, h2)
-        # but the above doesn't really test everything - we want a way to
-        # pass the handle directly into PyWinLong_AsVoidPtr.  One way to
-        # to that is to abuse win32api.GetProcAddress() - the 2nd param
-        # is passed to PyWinLong_AsVoidPtr() if it's not a string.
-        # passing a handle value of '1' should work - there is something
-        # at that ordinal
-        win32api.GetProcAddress(sys.dllhandle, h)
-
-    def testHandleInDict(self):
-        h = pywintypes.HANDLE(1)
-        d = {"foo": h}
-        self.assertEqual(d["foo"], h)
-
-    def testHandleInDictThenInt(self):
-        h = pywintypes.HANDLE(1)
-        d = {"foo": h}
-        self.assertEqual(d["foo"], 1)
-
-    def testHandleCompareNone(self):
-        h = pywintypes.HANDLE(1)
-        self.assertNotEqual(h, None)
-        self.assertNotEqual(None, h)
-        # ensure we use both __eq__ and __ne__ ops
-        self.assertFalse(h is None)
-        self.assertTrue(h is not None)
-
-    def testHandleCompareInt(self):
-        h = pywintypes.HANDLE(1)
-        self.assertNotEqual(h, 0)
-        self.assertEqual(h, 1)
-        # ensure we use both __eq__ and __ne__ ops
-        self.assertTrue(h == 1)
-        self.assertTrue(1 == h)
-        self.assertFalse(h != 1)
-        self.assertFalse(1 != h)
-        self.assertFalse(h == 0)
-        self.assertFalse(0 == h)
-        self.assertTrue(h != 0)
-        self.assertTrue(0 != h)
-
-    def testHandleNonZero(self):
-        h = pywintypes.HANDLE(0)
-        self.assertFalse(h)
-
-        h = pywintypes.HANDLE(1)
-        self.assertTrue(h)
-
-    def testLong(self):
-        # sys.maxsize+1 should always be a 'valid' handle, treated as an
-        # unsigned int, even though it is a long. Although pywin32 should not
-        # directly create such longs, using struct.unpack() with a P format
-        # may well return them. eg:
-        # >>> struct.unpack("P", struct.pack("P", -1))
-        # (4294967295L,)
-        pywintypes.HANDLE(sys.maxsize + 1)
-
-    def testGC(self):
-        # This used to provoke:
-        # Fatal Python error: unexpected exception during garbage collection
-        def make():
-            h = pywintypes.HANDLE(-2)
-            c = Cycle(h)
-
-        import gc
-
-        make()
-        gc.collect()
-
-    def testTypes(self):
-        self.assertRaises(TypeError, pywintypes.HANDLE, "foo")
-        self.assertRaises(TypeError, pywintypes.HANDLE, ())
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,137 +0,0 @@
-# General test module for win32api - please add some :)
-import array
-import os
-import sys
-import unittest
-
-import pywintypes
-import win32con
-import win32gui
-from win32clipboard import (
-    CloseClipboard,
-    EmptyClipboard,
-    GetClipboardData,
-    GetClipboardDataHandle,
-    GetClipboardFormatName,
-    GetGlobalMemory,
-    OpenClipboard,
-    RegisterClipboardFormat,
-    SetClipboardData,
-    SetClipboardText,
-)
-
-custom_format_name = "PythonClipboardTestFormat"
-
-
-class CrashingTestCase(unittest.TestCase):
-    def test_722082(self):
-        class crasher:
-            pass
-
-        obj = crasher()
-        OpenClipboard()
-        try:
-            EmptyClipboard()
-            # This used to crash - now correctly raises type error.
-            self.assertRaises(TypeError, SetClipboardData, 0, obj)
-        finally:
-            CloseClipboard()
-
-
-class TestBitmap(unittest.TestCase):
-    def setUp(self):
-        self.bmp_handle = None
-        try:
-            this_file = __file__
-        except NameError:
-            this_file = sys.argv[0]
-        this_dir = os.path.dirname(this_file)
-        self.bmp_name = os.path.join(
-            os.path.abspath(this_dir), "..", "Demos", "images", "smiley.bmp"
-        )
-        self.assertTrue(os.path.isfile(self.bmp_name), self.bmp_name)
-        flags = win32con.LR_DEFAULTSIZE | win32con.LR_LOADFROMFILE
-        self.bmp_handle = win32gui.LoadImage(
-            0, self.bmp_name, win32con.IMAGE_BITMAP, 0, 0, flags
-        )
-        self.assertTrue(self.bmp_handle, "Failed to get a bitmap handle")
-
-    def tearDown(self):
-        if self.bmp_handle:
-            win32gui.DeleteObject(self.bmp_handle)
-
-    def test_bitmap_roundtrip(self):
-        OpenClipboard()
-        try:
-            SetClipboardData(win32con.CF_BITMAP, self.bmp_handle)
-            got_handle = GetClipboardDataHandle(win32con.CF_BITMAP)
-            self.assertEqual(got_handle, self.bmp_handle)
-        finally:
-            CloseClipboard()
-
-
-class TestStrings(unittest.TestCase):
-    def setUp(self):
-        OpenClipboard()
-
-    def tearDown(self):
-        CloseClipboard()
-
-    def test_unicode(self):
-        val = "test-\xa9har"
-        SetClipboardData(win32con.CF_UNICODETEXT, val)
-        self.assertEqual(GetClipboardData(win32con.CF_UNICODETEXT), val)
-
-    def test_unicode_text(self):
-        val = "test-val"
-        SetClipboardText(val)
-        # GetClipboardData doesn't do auto string conversions -
-        # so CF_TEXT returns bytes.
-        expected = val.encode("latin1")
-        self.assertEqual(GetClipboardData(win32con.CF_TEXT), expected)
-        SetClipboardText(val, win32con.CF_UNICODETEXT)
-        self.assertEqual(GetClipboardData(win32con.CF_UNICODETEXT), val)
-
-    def test_string(self):
-        val = b"test"
-        SetClipboardData(win32con.CF_TEXT, val)
-        self.assertEqual(GetClipboardData(win32con.CF_TEXT), val)
-
-
-class TestGlobalMemory(unittest.TestCase):
-    def setUp(self):
-        OpenClipboard()
-
-    def tearDown(self):
-        CloseClipboard()
-
-    def test_mem(self):
-        val = b"test"
-        expected = b"test\0"
-        SetClipboardData(win32con.CF_TEXT, val)
-        # Get the raw data - this will include the '\0'
-        raw_data = GetGlobalMemory(GetClipboardDataHandle(win32con.CF_TEXT))
-        self.assertEqual(expected, raw_data)
-
-    def test_bad_mem(self):
-        self.assertRaises(pywintypes.error, GetGlobalMemory, 0)
-        self.assertRaises(pywintypes.error, GetGlobalMemory, -1)
-        if sys.getwindowsversion()[0] <= 5:
-            # For some reason, the value '1' dies from a 64bit process, but
-            # "works" (ie, gives the correct exception) from a 32bit process.
-            # just silently skip this value on Vista.
-            self.assertRaises(pywintypes.error, GetGlobalMemory, 1)
-
-    def test_custom_mem(self):
-        test_data = b"hello\x00\xff"
-        test_buffer = array.array("b", test_data)
-        cf = RegisterClipboardFormat(custom_format_name)
-        self.assertEqual(custom_format_name, GetClipboardFormatName(cf))
-        SetClipboardData(cf, test_buffer)
-        hglobal = GetClipboardDataHandle(cf)
-        data = GetGlobalMemory(hglobal)
-        self.assertEqual(data, test_data)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,213 +0,0 @@
-"""Test pywin32's error semantics"""
-
-import unittest
-
-import pythoncom
-import pywintypes
-import win32api
-import winerror
-
-
-class TestBase(unittest.TestCase):
-    def _testExceptionIndex(self, exc, index, expected):
-        # Check that exception.args is the same.
-        self.assertEqual(exc.args[index], expected)
-
-
-class TestAPISimple(TestBase):
-    def _getInvalidHandleException(self):
-        try:
-            win32api.CloseHandle(1)
-        except win32api.error as exc:
-            return exc
-        self.fail("Didn't get invalid-handle exception.")
-
-    def testSimple(self):
-        self.assertRaises(pywintypes.error, win32api.CloseHandle, 1)
-
-    def testErrnoIndex(self):
-        exc = self._getInvalidHandleException()
-        self._testExceptionIndex(exc, 0, winerror.ERROR_INVALID_HANDLE)
-
-    def testFuncIndex(self):
-        exc = self._getInvalidHandleException()
-        self._testExceptionIndex(exc, 1, "CloseHandle")
-
-    def testMessageIndex(self):
-        exc = self._getInvalidHandleException()
-        expected = win32api.FormatMessage(winerror.ERROR_INVALID_HANDLE).rstrip()
-        self._testExceptionIndex(exc, 2, expected)
-
-    def testUnpack(self):
-        try:
-            win32api.CloseHandle(1)
-            self.fail("expected exception!")
-        except win32api.error as exc:
-            self.assertEqual(exc.winerror, winerror.ERROR_INVALID_HANDLE)
-            self.assertEqual(exc.funcname, "CloseHandle")
-            expected_msg = win32api.FormatMessage(
-                winerror.ERROR_INVALID_HANDLE
-            ).rstrip()
-            self.assertEqual(exc.strerror, expected_msg)
-
-    def testAsStr(self):
-        exc = self._getInvalidHandleException()
-        err_msg = win32api.FormatMessage(winerror.ERROR_INVALID_HANDLE).rstrip()
-        # early on the result actually *was* a tuple - it must always look like one
-        err_tuple = (winerror.ERROR_INVALID_HANDLE, "CloseHandle", err_msg)
-        self.assertEqual(str(exc), str(err_tuple))
-
-    def testAsTuple(self):
-        exc = self._getInvalidHandleException()
-        err_msg = win32api.FormatMessage(winerror.ERROR_INVALID_HANDLE).rstrip()
-        # early on the result actually *was* a tuple - it must be able to be one
-        err_tuple = (winerror.ERROR_INVALID_HANDLE, "CloseHandle", err_msg)
-        self.assertEqual(exc.args, err_tuple)
-
-    def testClassName(self):
-        exc = self._getInvalidHandleException()
-        # The error class has always been named 'error'.  That's not ideal :(
-        self.assertEqual(exc.__class__.__name__, "error")
-
-    def testIdentity(self):
-        exc = self._getInvalidHandleException()
-        self.assertTrue(exc.__class__ is pywintypes.error)
-
-    def testBaseClass(self):
-        self.assertEqual(pywintypes.error.__bases__, (Exception,))
-
-    def testAttributes(self):
-        exc = self._getInvalidHandleException()
-        err_msg = win32api.FormatMessage(winerror.ERROR_INVALID_HANDLE).rstrip()
-        self.assertEqual(exc.winerror, winerror.ERROR_INVALID_HANDLE)
-        self.assertEqual(exc.strerror, err_msg)
-        self.assertEqual(exc.funcname, "CloseHandle")
-
-    # some tests for 'insane' args.
-    def testStrangeArgsNone(self):
-        try:
-            raise pywintypes.error
-            self.fail("Expected exception")
-        except pywintypes.error as exc:
-            self.assertEqual(exc.args, ())
-            self.assertEqual(exc.winerror, None)
-            self.assertEqual(exc.funcname, None)
-            self.assertEqual(exc.strerror, None)
-
-    def testStrangeArgsNotEnough(self):
-        try:
-            raise pywintypes.error("foo")
-            self.fail("Expected exception")
-        except pywintypes.error as exc:
-            self.assertEqual(exc.args[0], "foo")
-            # 'winerror' always args[0]
-            self.assertEqual(exc.winerror, "foo")
-            self.assertEqual(exc.funcname, None)
-            self.assertEqual(exc.strerror, None)
-
-    def testStrangeArgsTooMany(self):
-        try:
-            raise pywintypes.error("foo", "bar", "you", "never", "kn", 0)
-            self.fail("Expected exception")
-        except pywintypes.error as exc:
-            self.assertEqual(exc.args[0], "foo")
-            self.assertEqual(exc.args[-1], 0)
-            self.assertEqual(exc.winerror, "foo")
-            self.assertEqual(exc.funcname, "bar")
-            self.assertEqual(exc.strerror, "you")
-
-
-class TestCOMSimple(TestBase):
-    def _getException(self):
-        try:
-            pythoncom.StgOpenStorage("foo", None, 0)
-        except pythoncom.com_error as exc:
-            return exc
-        self.fail("Didn't get storage exception.")
-
-    def testIs(self):
-        self.assertTrue(pythoncom.com_error is pywintypes.com_error)
-
-    def testSimple(self):
-        self.assertRaises(pythoncom.com_error, pythoncom.StgOpenStorage, "foo", None, 0)
-
-    def testErrnoIndex(self):
-        exc = self._getException()
-        self._testExceptionIndex(exc, 0, winerror.STG_E_INVALIDFLAG)
-
-    def testMessageIndex(self):
-        exc = self._getException()
-        expected = win32api.FormatMessage(winerror.STG_E_INVALIDFLAG).rstrip()
-        self._testExceptionIndex(exc, 1, expected)
-
-    def testAsStr(self):
-        exc = self._getException()
-        err_msg = win32api.FormatMessage(winerror.STG_E_INVALIDFLAG).rstrip()
-        # early on the result actually *was* a tuple - it must always look like one
-        err_tuple = (winerror.STG_E_INVALIDFLAG, err_msg, None, None)
-        self.assertEqual(str(exc), str(err_tuple))
-
-    def testAsTuple(self):
-        exc = self._getException()
-        err_msg = win32api.FormatMessage(winerror.STG_E_INVALIDFLAG).rstrip()
-        # early on the result actually *was* a tuple - it must be able to be one
-        err_tuple = (winerror.STG_E_INVALIDFLAG, err_msg, None, None)
-        self.assertEqual(exc.args, err_tuple)
-
-    def testClassName(self):
-        exc = self._getException()
-        self.assertEqual(exc.__class__.__name__, "com_error")
-
-    def testIdentity(self):
-        exc = self._getException()
-        self.assertTrue(exc.__class__ is pywintypes.com_error)
-
-    def testBaseClass(self):
-        exc = self._getException()
-        self.assertEqual(pywintypes.com_error.__bases__, (Exception,))
-
-    def testAttributes(self):
-        exc = self._getException()
-        err_msg = win32api.FormatMessage(winerror.STG_E_INVALIDFLAG).rstrip()
-        self.assertEqual(exc.hresult, winerror.STG_E_INVALIDFLAG)
-        self.assertEqual(exc.strerror, err_msg)
-        self.assertEqual(exc.argerror, None)
-        self.assertEqual(exc.excepinfo, None)
-
-    def testStrangeArgsNone(self):
-        try:
-            raise pywintypes.com_error
-            self.fail("Expected exception")
-        except pywintypes.com_error as exc:
-            self.assertEqual(exc.args, ())
-            self.assertEqual(exc.hresult, None)
-            self.assertEqual(exc.strerror, None)
-            self.assertEqual(exc.argerror, None)
-            self.assertEqual(exc.excepinfo, None)
-
-    def testStrangeArgsNotEnough(self):
-        try:
-            raise pywintypes.com_error("foo")
-            self.fail("Expected exception")
-        except pywintypes.com_error as exc:
-            self.assertEqual(exc.args[0], "foo")
-            self.assertEqual(exc.hresult, "foo")
-            self.assertEqual(exc.strerror, None)
-            self.assertEqual(exc.excepinfo, None)
-            self.assertEqual(exc.argerror, None)
-
-    def testStrangeArgsTooMany(self):
-        try:
-            raise pywintypes.com_error("foo", "bar", "you", "never", "kn", 0)
-            self.fail("Expected exception")
-        except pywintypes.com_error as exc:
-            self.assertEqual(exc.args[0], "foo")
-            self.assertEqual(exc.args[-1], 0)
-            self.assertEqual(exc.hresult, "foo")
-            self.assertEqual(exc.strerror, "bar")
-            self.assertEqual(exc.excepinfo, "you")
-            self.assertEqual(exc.argerror, "never")
-
-
-if __name__ == "__main__":
-    unittest.main()