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

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

@@ -1,21 +0,0 @@
-# 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.
-
-
-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-attributes-on-modules
-    for path in pywin32_system32.__path__:
-        if os.path.isdir(path):
-            os.add_dll_directory(path)
-            break

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

@@ -1,291 +0,0 @@
-# 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)
-
-
-# TestProgram 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 suppressed.
-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

@@ -1,124 +0,0 @@
-# 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, `pip 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

@@ -1,40 +0,0 @@
-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

@@ -1,161 +0,0 @@
-# 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)