py2docfx 0.1.9.dev1886355__py3-none-any.whl → 0.1.9.dev1897554__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/win32/lib/pywin32_bootstrap.py

@@ -0,0 +1,29 @@
+# Imported by pywin32.pth to bootstrap the pywin32 environment in "portable"
+# environments or any other case where the post-install script isn't run.
+#
+# In short, there's a directory installed by pywin32 named 'pywin32_system32'
+# with some important DLLs which need to be found by Python when some pywin32
+# modules are imported.
+# If Python has `os.add_dll_directory()`, we need to call it with this path.
+# Otherwise, we add this path to PATH.
+
+
+try:
+    import pywin32_system32
+except ImportError:  # Python ≥3.6: replace ImportError with ModuleNotFoundError
+    pass
+else:
+    import os
+
+    # We're guaranteed only that __path__: Iterable[str]
+    # https://docs.python.org/3/reference/import.html#__path__
+    for path in pywin32_system32.__path__:
+        if os.path.isdir(path):
+            if hasattr(os, "add_dll_directory"):
+                os.add_dll_directory(path)
+            # This is to ensure the pywin32 path is in the beginning to find the
+            # pywin32 DLLs first and prevent other PATH entries to shadow them
+            elif not os.environ["PATH"].startswith(path):
+                os.environ["PATH"] = os.environ["PATH"].replace(os.pathsep + path, "")
+                os.environ["PATH"] = path + os.pathsep + os.environ["PATH"]
+            break

py2docfx/venv/venv1/Lib/site-packages/win32/lib/pywin32_testutil.py

@@ -0,0 +1,291 @@
+# Utilities for the pywin32 tests
+import gc
+import os
+import site
+import sys
+import unittest
+
+import winerror
+
+##
+## unittest related stuff
+##
+
+
+# This is a specialized TestCase adaptor which wraps a real test.
+class LeakTestCase(unittest.TestCase):
+    """An 'adaptor' which takes another test.  In debug builds we execute the
+    test once to remove one-off side-effects, then capture the total
+    reference count, then execute the test a few times.  If the total
+    refcount at the end is greater than we first captured, we have a leak!
+
+    In release builds the test is executed just once, as normal.
+
+    Generally used automatically by the test runner - you can safely
+    ignore this.
+    """
+
+    def __init__(self, real_test):
+        unittest.TestCase.__init__(self)
+        self.real_test = real_test
+        self.num_test_cases = 1
+        self.num_leak_iters = 2  # seems to be enough!
+        if hasattr(sys, "gettotalrefcount"):
+            self.num_test_cases += self.num_leak_iters
+
+    def countTestCases(self):
+        return self.num_test_cases
+
+    def __call__(self, result=None):
+        # For the COM suite's sake, always ensure we don't leak
+        # gateways/interfaces
+        from pythoncom import _GetGatewayCount, _GetInterfaceCount
+
+        gc.collect()
+        ni = _GetInterfaceCount()
+        ng = _GetGatewayCount()
+        self.real_test(result)
+        # Failed - no point checking anything else
+        if result.shouldStop or not result.wasSuccessful():
+            return
+        self._do_leak_tests(result)
+        gc.collect()
+        lost_i = _GetInterfaceCount() - ni
+        lost_g = _GetGatewayCount() - ng
+        if lost_i or lost_g:
+            msg = "%d interface objects and %d gateway objects leaked" % (
+                lost_i,
+                lost_g,
+            )
+            exc = AssertionError(msg)
+            result.addFailure(self.real_test, (exc.__class__, exc, None))
+
+    def runTest(self):
+        raise NotImplementedError("not used")
+
+    def _do_leak_tests(self, result=None):
+        try:
+            gtrc = sys.gettotalrefcount
+        except AttributeError:
+            return  # can't do leak tests in this build
+        # Assume already called once, to prime any caches etc
+        gc.collect()
+        trc = gtrc()
+        for i in range(self.num_leak_iters):
+            self.real_test(result)
+            if result.shouldStop:
+                break
+        del i  # created after we remembered the refcount!
+        # int division here means one or 2 stray references won't force
+        # failure, but one per loop
+        gc.collect()
+        lost = (gtrc() - trc) // self.num_leak_iters
+        if lost < 0:
+            msg = "LeakTest: %s appeared to gain %d references!!" % (
+                self.real_test,
+                -lost,
+            )
+            result.addFailure(self.real_test, (AssertionError, msg, None))
+        if lost > 0:
+            msg = "LeakTest: %s lost %d references" % (self.real_test, lost)
+            exc = AssertionError(msg)
+            result.addFailure(self.real_test, (exc.__class__, exc, None))
+
+
+class TestLoader(unittest.TestLoader):
+    def loadTestsFromTestCase(self, testCaseClass):
+        """Return a suite of all tests cases contained in testCaseClass"""
+        leak_tests = []
+        for name in self.getTestCaseNames(testCaseClass):
+            real_test = testCaseClass(name)
+            leak_test = self._getTestWrapper(real_test)
+            leak_tests.append(leak_test)
+        return self.suiteClass(leak_tests)
+
+    def fixupTestsForLeakTests(self, test):
+        if isinstance(test, unittest.TestSuite):
+            test._tests = [self.fixupTestsForLeakTests(t) for t in test._tests]
+            return test
+        else:
+            # just a normal test case.
+            return self._getTestWrapper(test)
+
+    def _getTestWrapper(self, test):
+        # one or 2 tests in the COM test suite set this...
+        no_leak_tests = getattr(test, "no_leak_tests", False)
+        if no_leak_tests:
+            print("Test says it doesn't want leak tests!")
+            return test
+        return LeakTestCase(test)
+
+    def loadTestsFromModule(self, mod):
+        if hasattr(mod, "suite"):
+            tests = mod.suite()
+        else:
+            tests = unittest.TestLoader.loadTestsFromModule(self, mod)
+        return self.fixupTestsForLeakTests(tests)
+
+    def loadTestsFromName(self, name, module=None):
+        test = unittest.TestLoader.loadTestsFromName(self, name, module)
+        if isinstance(test, unittest.TestSuite):
+            # print("Don't wrap suites yet!", test._tests)
+            pass  # hmmm?
+        elif isinstance(test, unittest.TestCase):
+            test = self._getTestWrapper(test)
+        else:
+            print("XXX - what is", test)
+        return test
+
+
+# Lots of classes necessary to support one simple feature: we want a 3rd
+# test result state - "SKIPPED" - to indicate that the test wasn't able
+# to be executed for various reasons.  Inspired by bzr's tests, but it
+# has other concepts, such as "Expected Failure", which we don't bother
+# with.
+
+# win32 error codes that probably mean we need to be elevated (ie, if we
+# aren't elevated, we treat these error codes as 'skipped')
+non_admin_error_codes = [
+    winerror.ERROR_ACCESS_DENIED,
+    winerror.ERROR_PRIVILEGE_NOT_HELD,
+]
+
+_is_admin = None
+
+
+def check_is_admin():
+    global _is_admin
+    if _is_admin is None:
+        import pythoncom
+        from win32com.shell.shell import IsUserAnAdmin
+
+        try:
+            _is_admin = IsUserAnAdmin()
+        except pythoncom.com_error as exc:
+            if exc.hresult != winerror.E_NOTIMPL:
+                raise
+            # not impl on this platform - must be old - assume is admin
+            _is_admin = True
+    return _is_admin
+
+
+# Find a test "fixture" (eg, binary test file) expected to be very close to
+# the test being run.
+# If the tests are being run from the "installed" version, then these fixtures
+# probably don't exist - the test is "skipped".
+# But it's fatal if we think we might be running from a pywin32 source tree.
+def find_test_fixture(basename, extra_dir="."):
+    # look for the test file in various places
+    candidates = [
+        os.path.dirname(sys.argv[0]),
+        extra_dir,
+        ".",
+    ]
+    for candidate in candidates:
+        fname = os.path.join(candidate, basename)
+        if os.path.isfile(fname):
+            return fname
+    else:
+        # Can't find it - see if this is expected or not.
+        # This module is typically always in the installed dir, so use argv[0]
+        this_file = os.path.normcase(os.path.abspath(sys.argv[0]))
+        dirs_to_check = site.getsitepackages()[:]
+        if site.USER_SITE:
+            dirs_to_check.append(site.USER_SITE)
+
+        for d in dirs_to_check:
+            d = os.path.normcase(d)
+            if os.path.commonprefix([this_file, d]) == d:
+                # looks like we are in an installed Python, so skip the text.
+                raise TestSkipped(f"Can't find test fixture '{fname}'")
+        # Looks like we are running from source, so this is fatal.
+        raise RuntimeError(f"Can't find test fixture '{fname}'")
+
+
+# If this exception is raised by a test, the test is reported as a 'skip'
+class TestSkipped(Exception):
+    pass
+
+
+# The 'TestResult' subclass that records the failures and has the special
+# handling for the TestSkipped exception.
+class TestResult(unittest.TextTestResult):
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        self.skips = {}  # count of skips for each reason.
+
+    def addError(self, test, err):
+        """Called when an error has occurred. 'err' is a tuple of values as
+        returned by sys.exc_info().
+        """
+        # translate a couple of 'well-known' exceptions into 'skipped'
+        import pywintypes
+
+        exc_val = err[1]
+        # translate ERROR_ACCESS_DENIED for non-admin users to be skipped.
+        # (access denied errors for an admin user aren't expected.)
+        if (
+            isinstance(exc_val, pywintypes.error)
+            and exc_val.winerror in non_admin_error_codes
+            and not check_is_admin()
+        ):
+            exc_val = TestSkipped(exc_val)
+        # and COM errors due to objects not being registered (the com test
+        # suite will attempt to catch this and handle it itself if the user
+        # is admin)
+        elif isinstance(exc_val, pywintypes.com_error) and exc_val.hresult in [
+            winerror.CO_E_CLASSSTRING,
+            winerror.REGDB_E_CLASSNOTREG,
+            winerror.TYPE_E_LIBNOTREGISTERED,
+        ]:
+            exc_val = TestSkipped(exc_val)
+        # NotImplemented generally means the platform doesn't support the
+        # functionality.
+        elif isinstance(exc_val, NotImplementedError):
+            exc_val = TestSkipped(NotImplementedError)
+
+        if isinstance(exc_val, TestSkipped):
+            reason = exc_val.args[0]
+            # if the reason itself is another exception, get its args.
+            try:
+                reason = tuple(reason.args)
+            except (AttributeError, TypeError):
+                pass
+            self.skips.setdefault(reason, 0)
+            self.skips[reason] += 1
+            if self.showAll:
+                self.stream.writeln(f"SKIP ({reason})")
+            elif self.dots:
+                self.stream.write("S")
+                self.stream.flush()
+            return
+        super().addError(test, err)
+
+    def printErrors(self):
+        super().printErrors()
+        for reason, num_skipped in self.skips.items():
+            self.stream.writeln("SKIPPED: %d tests - %s" % (num_skipped, reason))
+
+
+# TestRunner subclass necessary just to get our TestResult hooked up.
+class TestRunner(unittest.TextTestRunner):
+    def _makeResult(self):
+        return TestResult(self.stream, self.descriptions, self.verbosity)
+
+
+# TestProgream subclass necessary just to get our TestRunner hooked up,
+# which is necessary to get our TestResult hooked up *sob*
+class TestProgram(unittest.TestProgram):
+    def runTests(self):
+        # clobber existing runner - *sob* - it shouldn't be this hard
+        self.testRunner = TestRunner(verbosity=self.verbosity)
+        unittest.TestProgram.runTests(self)
+
+
+# A convenient entry-point - if used, 'SKIPPED' exceptions will be supressed.
+def testmain(*args, **kw):
+    new_kw = kw.copy()
+    if "testLoader" not in new_kw:
+        new_kw["testLoader"] = TestLoader()
+    program_class = new_kw.get("testProgram", TestProgram)
+    program_class(*args, **new_kw)

py2docfx/venv/venv1/Lib/site-packages/win32/lib/pywintypes.py

@@ -0,0 +1,124 @@
+# Magic utility that "redirects" to pywintypesXX.dll
+import importlib.machinery
+import importlib.util
+import os
+import sys
+
+
+def __import_pywin32_system_module__(modname, globs):
+    # This has been through a number of iterations.  The problem: how to
+    # locate pywintypesXX.dll when it may be in a number of places, and how
+    # to avoid ever loading it twice.  This problem is compounded by the
+    # fact that the "right" way to do this requires win32api, but this
+    # itself requires pywintypesXX.
+    # And the killer problem is that someone may have done 'import win32api'
+    # before this code is called.  In that case Windows will have already
+    # loaded pywintypesXX as part of loading win32api - but by the time
+    # we get here, we may locate a different one.  This appears to work, but
+    # then starts raising bizarre TypeErrors complaining that something
+    # is not a pywintypes type when it clearly is!
+
+    # So in what we hope is the last major iteration of this, we now
+    # rely on a _win32sysloader module, implemented in C but not relying
+    # on pywintypesXX.dll.  It then can check if the DLL we are looking for
+    # lib is already loaded.
+    # See if this is a debug build.
+    suffix = "_d" if "_d.pyd" in importlib.machinery.EXTENSION_SUFFIXES else ""
+    filename = "%s%d%d%s.dll" % (
+        modname,
+        sys.version_info.major,
+        sys.version_info.minor,
+        suffix,
+    )
+    if hasattr(sys, "frozen"):
+        # If we are running from a frozen program (py2exe, McMillan, freeze, PyInstaller)
+        # then we try and load the DLL from our sys.path
+        # XXX - This path may also benefit from _win32sysloader?  However,
+        # MarkH has never seen the DLL load problem with py2exe programs...
+        for look in sys.path:
+            # If the sys.path entry is a (presumably) .zip file, use the
+            # directory
+            if os.path.isfile(look):
+                look = os.path.dirname(look)
+            found = os.path.join(look, filename)
+            if os.path.isfile(found):
+                break
+        else:
+            raise ImportError(f"Module '{modname}' isn't in frozen sys.path {sys.path}")
+    else:
+        # First see if it already in our process - if so, we must use that.
+        import _win32sysloader
+
+        found = _win32sysloader.GetModuleFilename(filename)
+        if found is None:
+            # We ask Windows to load it next.  This is in an attempt to
+            # get the exact same module loaded should pywintypes be imported
+            # first (which is how we are here) or if, eg, win32api was imported
+            # first thereby implicitly loading the DLL.
+
+            # Sadly though, it doesn't quite work - if pywintypesXX.dll
+            # is in system32 *and* the executable's directory, on XP SP2, an
+            # import of win32api will cause Windows to load pywintypes
+            # from system32, where LoadLibrary for that name will
+            # load the one in the exe's dir.
+            # That shouldn't really matter though, so long as we only ever
+            # get one loaded.
+            found = _win32sysloader.LoadModule(filename)
+        if found is None:
+            # Windows can't find it - which although isn't relevent here,
+            # means that we *must* be the first win32 import, as an attempt
+            # to import win32api etc would fail when Windows attempts to
+            # locate the DLL.
+            # This is most likely to happen for "non-admin" installs, where
+            # we can't put the files anywhere else on the global path.
+
+            # If there is a version in our Python directory, use that
+            if os.path.isfile(os.path.join(sys.prefix, filename)):
+                found = os.path.join(sys.prefix, filename)
+        if found is None:
+            # Not in the Python directory?  Maybe we were installed via
+            # easy_install...
+            if os.path.isfile(os.path.join(os.path.dirname(__file__), filename)):
+                found = os.path.join(os.path.dirname(__file__), filename)
+
+        # There are 2 site-packages directories - one "global" and one "user".
+        # We could be in either, or both (but with different versions!). Factors include
+        # virtualenvs, post-install script being run or not, `setup.py install` flags, etc.
+
+        # In a worst-case, it means, say 'python -c "import win32api"'
+        # will not work but 'python -c "import pywintypes, win32api"' will,
+        # but it's better than nothing.
+
+        # We use the same logic as pywin32_bootstrap to find potential location for the dll
+        # Simply import pywin32_system32 and look in the paths in pywin32_system32.__path__
+
+        if found is None:
+            import pywin32_system32
+
+            for path in pywin32_system32.__path__:
+                maybe = os.path.join(path, filename)
+                if os.path.isfile(maybe):
+                    found = maybe
+                    break
+
+        if found is None:
+            # give up in disgust.
+            raise ImportError(f"No system module '{modname}' ({filename})")
+    # After importing the module, sys.modules is updated to the DLL we just
+    # loaded - which isn't what we want. So we update sys.modules to refer to
+    # this module, and update our globals from it.
+    old_mod = sys.modules[modname]
+    # Load the DLL.
+    loader = importlib.machinery.ExtensionFileLoader(modname, found)
+    spec = importlib.machinery.ModuleSpec(name=modname, loader=loader, origin=found)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+
+    # Check the sys.modules[] behaviour we describe above is true...
+    assert sys.modules[modname] is mod
+    # as above - re-reset to the *old* module object then update globs.
+    sys.modules[modname] = old_mod
+    globs.update(mod.__dict__)
+
+
+__import_pywin32_system_module__("pywintypes", globals())

py2docfx/venv/venv1/Lib/site-packages/win32/lib/rasutil.py

@@ -0,0 +1,40 @@
+import win32ras
+
+stateStrings = {
+    win32ras.RASCS_OpenPort: "OpenPort",
+    win32ras.RASCS_PortOpened: "PortOpened",
+    win32ras.RASCS_ConnectDevice: "ConnectDevice",
+    win32ras.RASCS_DeviceConnected: "DeviceConnected",
+    win32ras.RASCS_AllDevicesConnected: "AllDevicesConnected",
+    win32ras.RASCS_Authenticate: "Authenticate",
+    win32ras.RASCS_AuthNotify: "AuthNotify",
+    win32ras.RASCS_AuthRetry: "AuthRetry",
+    win32ras.RASCS_AuthCallback: "AuthCallback",
+    win32ras.RASCS_AuthChangePassword: "AuthChangePassword",
+    win32ras.RASCS_AuthProject: "AuthProject",
+    win32ras.RASCS_AuthLinkSpeed: "AuthLinkSpeed",
+    win32ras.RASCS_AuthAck: "AuthAck",
+    win32ras.RASCS_ReAuthenticate: "ReAuthenticate",
+    win32ras.RASCS_Authenticated: "Authenticated",
+    win32ras.RASCS_PrepareForCallback: "PrepareForCallback",
+    win32ras.RASCS_WaitForModemReset: "WaitForModemReset",
+    win32ras.RASCS_WaitForCallback: "WaitForCallback",
+    win32ras.RASCS_Projected: "Projected",
+    win32ras.RASCS_StartAuthentication: "StartAuthentication",
+    win32ras.RASCS_CallbackComplete: "CallbackComplete",
+    win32ras.RASCS_LogonNetwork: "LogonNetwork",
+    win32ras.RASCS_Interactive: "Interactive",
+    win32ras.RASCS_RetryAuthentication: "RetryAuthentication",
+    win32ras.RASCS_CallbackSetByCaller: "CallbackSetByCaller",
+    win32ras.RASCS_PasswordExpired: "PasswordExpired",
+    win32ras.RASCS_Connected: "Connected",
+    win32ras.RASCS_Disconnected: "Disconnected",
+}
+
+
+def TestCallback(hras, msg, state, error, exterror):
+    print("Callback called with ", hras, msg, stateStrings[state], error, exterror)
+
+
+def test(rasName="_ Divert Off"):
+    return win32ras.Dial(None, None, (rasName,), TestCallback)

py2docfx/venv/venv1/Lib/site-packages/win32/lib/regcheck.py

@@ -0,0 +1,161 @@
+# This module is very old and useless in this day and age!  It will be
+# removed in a few years (ie, 2009 or so...)
+
+import warnings
+
+warnings.warn(
+    "The regcheck module has been pending deprecation since build 210",
+    category=PendingDeprecationWarning,
+)
+
+import os
+import sys
+
+import regutil
+import win32api
+import win32con
+
+
+def CheckRegisteredExe(exename):
+    try:
+        os.stat(
+            win32api.RegQueryValue(
+                regutil.GetRootKey(), regutil.GetAppPathsKey() + "\\" + exename
+            )
+        )
+    except (OSError, win32api.error):
+        print("Registration of %s - Not registered correctly" % exename)
+
+
+def CheckPathString(pathString):
+    for path in pathString.split(";"):
+        if not os.path.isdir(path):
+            return "'%s' is not a valid directory!" % path
+    return None
+
+
+def CheckPythonPaths(verbose):
+    if verbose:
+        print("Python Paths:")
+    # Check the core path
+    if verbose:
+        print("\tCore Path:", end=" ")
+    try:
+        appPath = win32api.RegQueryValue(
+            regutil.GetRootKey(), regutil.BuildDefaultPythonKey() + "\\PythonPath"
+        )
+    except win32api.error as exc:
+        print("** does not exist - ", exc.strerror)
+    problem = CheckPathString(appPath)
+    if problem:
+        print(problem)
+    else:
+        if verbose:
+            print(appPath)
+
+    key = win32api.RegOpenKey(
+        regutil.GetRootKey(),
+        regutil.BuildDefaultPythonKey() + "\\PythonPath",
+        0,
+        win32con.KEY_READ,
+    )
+    try:
+        keyNo = 0
+        while 1:
+            try:
+                appName = win32api.RegEnumKey(key, keyNo)
+                appPath = win32api.RegQueryValue(key, appName)
+                if verbose:
+                    print("\t" + appName + ":", end=" ")
+                if appPath:
+                    problem = CheckPathString(appPath)
+                    if problem:
+                        print(problem)
+                    else:
+                        if verbose:
+                            print(appPath)
+                else:
+                    if verbose:
+                        print("(empty)")
+                keyNo += 1
+            except win32api.error:
+                break
+    finally:
+        win32api.RegCloseKey(key)
+
+
+def CheckHelpFiles(verbose):
+    if verbose:
+        print("Help Files:")
+    try:
+        key = win32api.RegOpenKey(
+            regutil.GetRootKey(),
+            regutil.BuildDefaultPythonKey() + "\\Help",
+            0,
+            win32con.KEY_READ,
+        )
+    except win32api.error as exc:
+        import winerror
+
+        if exc.winerror != winerror.ERROR_FILE_NOT_FOUND:
+            raise
+        return
+
+    try:
+        keyNo = 0
+        while 1:
+            try:
+                helpDesc = win32api.RegEnumKey(key, keyNo)
+                helpFile = win32api.RegQueryValue(key, helpDesc)
+                if verbose:
+                    print("\t" + helpDesc + ":", end=" ")
+                # query the os section.
+                try:
+                    os.stat(helpFile)
+                    if verbose:
+                        print(helpFile)
+                except OSError:
+                    print("** Help file %s does not exist" % helpFile)
+                keyNo += 1
+            except win32api.error as exc:
+                import winerror
+
+                if exc.winerror != winerror.ERROR_NO_MORE_ITEMS:
+                    raise
+                break
+    finally:
+        win32api.RegCloseKey(key)
+
+
+def CheckRegisteredModules(verbose):
+    # Check out all registered modules.
+    k = regutil.BuildDefaultPythonKey() + "\\Modules"
+    try:
+        keyhandle = win32api.RegOpenKey(regutil.GetRootKey(), k)
+        print("WARNING: 'Modules' registry entry is deprectated and evil!")
+    except win32api.error as exc:
+        import winerror
+
+        if exc.winerror != winerror.ERROR_FILE_NOT_FOUND:
+            raise
+        return
+
+
+def CheckRegistry(verbose=0):
+    # check the registered modules
+    if verbose and "pythonpath" in os.environ:
+        print("Warning - PythonPath in environment - please check it!")
+    # Check out all paths on sys.path
+
+    CheckPythonPaths(verbose)
+    CheckHelpFiles(verbose)
+    CheckRegisteredModules(verbose)
+    CheckRegisteredExe("Python.exe")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "-q":
+        verbose = 0
+    else:
+        verbose = 1
+    CheckRegistry(verbose)