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

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

@@ -1,174 +0,0 @@
-import unittest
-
-import netbios
-import win32api
-import win32wnet
-
-RESOURCE_CONNECTED = 0x00000001
-RESOURCE_GLOBALNET = 0x00000002
-RESOURCE_REMEMBERED = 0x00000003
-RESOURCE_RECENT = 0x00000004
-RESOURCE_CONTEXT = 0x00000005
-RESOURCETYPE_ANY = 0x00000000
-RESOURCETYPE_DISK = 0x00000001
-RESOURCETYPE_PRINT = 0x00000002
-RESOURCETYPE_RESERVED = 0x00000008
-RESOURCETYPE_UNKNOWN = 0xFFFFFFFF
-RESOURCEUSAGE_CONNECTABLE = 0x00000001
-RESOURCEUSAGE_CONTAINER = 0x00000002
-RESOURCEDISPLAYTYPE_GENERIC = 0x00000000
-RESOURCEDISPLAYTYPE_DOMAIN = 0x00000001
-RESOURCEDISPLAYTYPE_SERVER = 0x00000002
-RESOURCEDISPLAYTYPE_SHARE = 0x00000003
-
-
-NETRESOURCE_attributes = [
-    ("dwScope", int),
-    ("dwType", int),
-    ("dwDisplayType", int),
-    ("dwUsage", int),
-    ("lpLocalName", str),
-    ("lpRemoteName", str),
-    ("lpComment", str),
-    ("lpProvider", str),
-]
-
-NCB_attributes = [
-    ("Command", int),
-    ("Retcode", int),
-    ("Lsn", int),
-    ("Num", int),
-    #    ("Bufflen", int), - read-only
-    ("Callname", str),
-    ("Name", str),
-    ("Rto", int),
-    ("Sto", int),
-    ("Lana_num", int),
-    ("Cmd_cplt", int),
-    ("Event", int),
-    ("Post", int),
-]
-
-
-class TestCase(unittest.TestCase):
-    def testGetUser(self):
-        self.assertEqual(win32api.GetUserName(), win32wnet.WNetGetUser())
-
-    def _checkItemAttributes(self, item, attrs):
-        for attr, typ in attrs:
-            val = getattr(item, attr)
-            if typ is int:
-                self.assertTrue(
-                    isinstance(val, int), f"Attr {attr!r} has value {val!r}"
-                )
-                new_val = val + 1
-            elif typ is str:
-                if val is not None:
-                    # must be string
-                    self.assertTrue(
-                        isinstance(val, str), f"Attr {attr!r} has value {val!r}"
-                    )
-                    new_val = val + " new value"
-                else:
-                    new_val = "new value"
-            else:
-                self.fail(f"Don't know what {typ} is")
-            # set the attribute just to make sure we can.
-            setattr(item, attr, new_val)
-
-    def testNETRESOURCE(self):
-        nr = win32wnet.NETRESOURCE()
-        self._checkItemAttributes(nr, NETRESOURCE_attributes)
-
-    def testWNetEnumResource(self):
-        handle = win32wnet.WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_ANY, 0, None)
-        try:
-            while 1:
-                items = win32wnet.WNetEnumResource(handle, 0)
-                if len(items) == 0:
-                    break
-                for item in items:
-                    self._checkItemAttributes(item, NETRESOURCE_attributes)
-        finally:
-            handle.Close()
-
-    def testNCB(self):
-        ncb = win32wnet.NCB()
-        self._checkItemAttributes(ncb, NCB_attributes)
-
-    def testNetbios(self):
-        # taken from the demo code in netbios.py
-        ncb = win32wnet.NCB()
-        ncb.Command = netbios.NCBENUM
-        la_enum = netbios.LANA_ENUM()
-        ncb.Buffer = la_enum
-        rc = win32wnet.Netbios(ncb)
-        self.assertEqual(rc, 0)
-        for i in range(la_enum.length):
-            ncb.Reset()
-            ncb.Command = netbios.NCBRESET
-            ncb.Lana_num = la_enum.lana[i]
-            rc = win32wnet.Netbios(ncb)
-            self.assertEqual(rc, 0)
-            ncb.Reset()
-            ncb.Command = netbios.NCBASTAT
-            ncb.Lana_num = la_enum.lana[i]
-            ncb.Callname = b"*               "
-            adapter = netbios.ADAPTER_STATUS()
-            ncb.Buffer = adapter
-            win32wnet.Netbios(ncb)
-            # expect 6 bytes in the mac address.
-            self.assertTrue(len(adapter.adapter_address), 6)
-
-    def iterConnectableShares(self):
-        nr = win32wnet.NETRESOURCE()
-        nr.dwScope = RESOURCE_GLOBALNET
-        nr.dwUsage = RESOURCEUSAGE_CONTAINER
-        nr.lpRemoteName = "\\\\" + win32api.GetComputerName()
-
-        handle = win32wnet.WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_ANY, 0, nr)
-        while 1:
-            items = win32wnet.WNetEnumResource(handle, 0)
-            if len(items) == 0:
-                break
-            for item in items:
-                if item.dwDisplayType == RESOURCEDISPLAYTYPE_SHARE:
-                    yield item
-
-    def findUnusedDriveLetter(self):
-        existing = [
-            x[0].lower() for x in win32api.GetLogicalDriveStrings().split("\0") if x
-        ]
-        handle = win32wnet.WNetOpenEnum(RESOURCE_REMEMBERED, RESOURCETYPE_DISK, 0, None)
-        try:
-            while 1:
-                items = win32wnet.WNetEnumResource(handle, 0)
-                if len(items) == 0:
-                    break
-                xtra = [i.lpLocalName[0].lower() for i in items if i.lpLocalName]
-                existing.extend(xtra)
-        finally:
-            handle.Close()
-        for maybe in "defghijklmnopqrstuvwxyz":
-            if maybe not in existing:
-                return maybe
-        self.fail("All drive mappings are taken?")
-
-    def testAddConnection(self):
-        localName = self.findUnusedDriveLetter() + ":"
-        for share in self.iterConnectableShares():
-            share.lpLocalName = localName
-            win32wnet.WNetAddConnection2(share)
-            win32wnet.WNetCancelConnection2(localName, 0, 0)
-            break
-
-    def testAddConnectionOld(self):
-        localName = self.findUnusedDriveLetter() + ":"
-        for share in self.iterConnectableShares():
-            win32wnet.WNetAddConnection2(share.dwType, localName, share.lpRemoteName)
-            win32wnet.WNetCancelConnection2(localName, 0, 0)
-            break
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,223 +0,0 @@
-import os
-import re
-import sys
-import traceback
-import unittest
-
-import pywin32_testutil
-
-# A list of demos that depend on user-interface of *any* kind.  Tests listed
-# here are not suitable for unattended testing.
-ui_demos = """GetSaveFileName print_desktop win32cred_demo win32gui_demo
-              win32gui_dialog win32gui_menu win32gui_taskbar
-              win32rcparser_demo winprocess win32console_demo
-              win32clipboard_bitmapdemo
-              win32gui_devicenotify
-              NetValidatePasswordPolicy""".split()
-# Other demos known as 'bad' (or at least highly unlikely to work)
-# desktopmanager: hangs (well, hangs for 60secs or so...)
-# EvtSubscribe_*: must be run together:
-# SystemParametersInfo: a couple of the params cause markh to hang, and there's
-# no great reason to adjust (twice!) all those system settings!
-bad_demos = """desktopmanager win32comport_demo
-               EvtSubscribe_pull EvtSubscribe_push
-               SystemParametersInfo
-            """.split()
-
-argvs = {
-    "rastest": ("-l",),
-}
-
-no_user_interaction = True
-
-# re to pull apart an exception line into the exception type and the args.
-re_exception = re.compile(r"([a-zA-Z0-9_.]*): (.*)$")
-
-
-def find_exception_in_output(data):
-    have_traceback = False
-    for line in data.splitlines():
-        line = line.decode("ascii")  # not sure what the correct encoding is...
-        if line.startswith("Traceback ("):
-            have_traceback = True
-            continue
-        if line.startswith(" "):
-            continue
-        if have_traceback:
-            # first line not starting with a space since the traceback.
-            # must be the exception!
-            m = re_exception.match(line)
-            if m:
-                exc_type, args = m.groups()
-                # get hacky - get the *real* exception object from the name.
-                bits = exc_type.split(".", 1)
-                if len(bits) > 1:
-                    mod = __import__(bits[0])
-                    exc = getattr(mod, bits[1])
-                else:
-                    # probably builtin
-                    exc = eval(bits[0])
-            else:
-                # hrm - probably just an exception with no args
-                try:
-                    exc = eval(line.strip())
-                    args = "()"
-                except:
-                    return None
-            # try and turn the args into real args.
-            try:
-                args = eval(args)
-            except:
-                pass
-            if not isinstance(args, tuple):
-                args = (args,)
-            # try and instantiate the exception.
-            try:
-                ret = exc(*args)
-            except:
-                ret = None
-            return ret
-        # apparently not - keep looking...
-        have_traceback = False
-
-
-class TestRunner:
-    def __init__(self, argv):
-        self.argv = argv
-        self.__name__ = f"Test Runner for cmdline {argv}"
-
-    def __call__(self):
-        import subprocess
-
-        p = subprocess.Popen(
-            self.argv, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
-        )
-        output, _ = p.communicate()
-        rc = p.returncode
-
-        if rc:
-            base = os.path.basename(self.argv[1])
-            # See if we can detect and reconstruct an exception in the output.
-            reconstituted = find_exception_in_output(output)
-            assert (
-                reconstituted is not None
-            ), f"{base} failed with exit code {rc}.  Output is:\n{output}"
-            raise reconstituted
-
-
-def get_demo_tests():
-    import win32api
-
-    ret = []
-    demo_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "Demos"))
-    assert os.path.isdir(demo_dir), demo_dir
-    for name in os.listdir(demo_dir):
-        base, ext = os.path.splitext(name)
-        if base in ui_demos and no_user_interaction:
-            continue
-        # Skip any other files than .py and bad tests in any case
-        if ext != ".py" or base in bad_demos:
-            continue
-        argv = (sys.executable, os.path.join(demo_dir, base + ".py")) + argvs.get(
-            base, ()
-        )
-        ret.append(
-            unittest.FunctionTestCase(
-                TestRunner(argv), description="win32/demos/" + name
-            )
-        )
-    return ret
-
-
-def import_all():
-    # Some hacks for import order - dde depends on win32ui
-    try:
-        import win32ui
-    except ImportError:
-        pass  # 'what-ev-a....'
-
-    import win32api
-
-    dir = os.path.dirname(win32api.__file__)
-    num = 0
-    is_debug = os.path.splitext(os.path.basename(win32api.__file__))[0].endswith("_d")
-    for name in os.listdir(dir):
-        base, ext = os.path.splitext(name)
-        # handle `modname.cp310-win_amd64.pyd` etc
-        base = base.split(".")[0]
-        if (
-            (ext == ".pyd")
-            and name != "_winxptheme.pyd"
-            and is_debug == base.endswith("_d")
-        ):
-            try:
-                __import__(base)
-            except:
-                print("FAILED to import", name)
-                raise
-            num += 1
-
-
-def suite():
-    # Loop over all .py files here, except me :)
-    try:
-        me = __file__
-    except NameError:
-        me = sys.argv[0]
-    me = os.path.abspath(me)
-    files = os.listdir(os.path.dirname(me))
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.FunctionTestCase(import_all))
-    for file in files:
-        base, ext = os.path.splitext(file)
-        if ext == ".py" and os.path.basename(me) != file:
-            try:
-                mod = __import__(base)
-            except:
-                print("FAILED to import test module %r" % base)
-                traceback.print_exc()
-                continue
-            if hasattr(mod, "suite"):
-                test = mod.suite()
-            else:
-                test = unittest.defaultTestLoader.loadTestsFromModule(mod)
-            suite.addTest(test)
-    for test in get_demo_tests():
-        suite.addTest(test)
-    return suite
-
-
-class CustomLoader(pywin32_testutil.TestLoader):
-    def loadTestsFromModule(self, module):
-        return self.fixupTestsForLeakTests(suite())
-
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Test runner for PyWin32/win32")
-    parser.add_argument(
-        "-no-user-interaction",
-        default=False,
-        action="store_true",
-        help="(This is now the default - use `-user-interaction` to include them)",
-    )
-
-    parser.add_argument(
-        "-user-interaction",
-        action="store_true",
-        help="Include tests which require user interaction",
-    )
-
-    parsed_args, remains = parser.parse_known_args()
-
-    if parsed_args.no_user_interaction:
-        print(
-            "Note: -no-user-interaction is now the default, run with `-user-interaction` to include them."
-        )
-
-    no_user_interaction = not parsed_args.user_interaction
-
-    sys.argv = [sys.argv[0]] + remains
-
-    pywin32_testutil.testmain(testLoader=CustomLoader())

py2docfx/venv/venv1/Lib/site-packages/win32/winxpgui.py

@@ -1,13 +0,0 @@
-"""\
-The `winxpgui` module is obsolete and has been completely replaced \
-by `win32gui` and `win32console.GetConsoleWindow`. Use those instead. \
-"""
-
-import warnings
-
-from win32console import (  # nopycln: import
-    GetConsoleWindow as GetConsoleWindow,  # noqa: PLC0414 # Explicit re-export
-)
-from win32gui import *  # nopycln: import
-
-warnings.warn(str(__doc__), category=DeprecationWarning)

py2docfx/venv/venv1/Lib/site-packages/win32com/__init__.py

@@ -1,134 +0,0 @@
-#
-# Initialization for the win32com package
-#
-from __future__ import annotations
-
-import os
-import sys
-
-import pythoncom
-import win32api
-
-# flag if we are in a "frozen" build.
-_frozen = getattr(sys, "frozen", False)
-# pythoncom dumbly defaults this to zero - we believe sys.frozen over it.
-if _frozen and not getattr(pythoncom, "frozen", 0):
-    pythoncom.frozen = sys.frozen
-
-# Add support for an external "COM Extensions" path.
-#  Concept is that you can register a seperate path to be used for
-#  COM extensions, outside of the win32com directory.  These modules, however,
-#  look identical to win32com built-in modules.
-#  This is the technique that we use for the "standard" COM extensions.
-#  eg "win32com.mapi" or "win32com.axscript" both work, even though they do not
-#  live under the main win32com directory.
-__gen_path__ = ""
-__build_path__ = None
-### TODO - Load _all_ \\Extensions subkeys - for now, we only read the default
-### Modules will work if loaded into "win32comext" path.
-
-# Ensure we're working on __path__ as list, not Iterable
-__path__: list[str] = list(__path__)  # type: ignore[no-redef]
-
-
-def SetupEnvironment():
-    HKEY_LOCAL_MACHINE = -2147483646  # Avoid pulling in win32con for just these...
-    KEY_QUERY_VALUE = 0x1
-    # Open the root key once, as this is quite slow on NT.
-    try:
-        keyName = "SOFTWARE\\Python\\PythonCore\\%s\\PythonPath\\win32com" % sys.winver
-        key = win32api.RegOpenKey(HKEY_LOCAL_MACHINE, keyName, 0, KEY_QUERY_VALUE)
-    except (win32api.error, AttributeError):
-        key = None
-
-    try:
-        found = 0
-        if key is not None:
-            try:
-                __path__.append(win32api.RegQueryValue(key, "Extensions"))
-                found = 1
-            except win32api.error:
-                # Nothing registered
-                pass
-        if not found:
-            try:
-                __path__.append(
-                    win32api.GetFullPathName(__path__[0] + "\\..\\win32comext")
-                )
-            except win32api.error:
-                # Give up in disgust!
-                pass
-
-        # For the sake of developers, we also look up a "BuildPath" key
-        # If extension modules add support, we can load their .pyd's from a completely
-        # different directory (see the comments below)
-        try:
-            if key is not None:
-                global __build_path__
-                __build_path__ = win32api.RegQueryValue(key, "BuildPath")
-                __path__.append(__build_path__)
-        except win32api.error:
-            # __build_path__ neednt be defined.
-            pass
-        global __gen_path__
-        if key is not None:
-            try:
-                __gen_path__ = win32api.RegQueryValue(key, "GenPath")
-            except win32api.error:
-                pass
-    finally:
-        if key is not None:
-            key.Close()
-
-
-# A Helper for developers.  A sub-package's __init__ can call this help function,
-# which allows the .pyd files for the extension to live in a special "Build" directory
-# (which the win32com developers do!)
-def __PackageSupportBuildPath__(package_path):
-    # See if we have a special directory for the binaries (for developers)
-    if not _frozen and __build_path__:
-        package_path.append(__build_path__)
-
-
-if not _frozen:
-    SetupEnvironment()
-
-# If we don't have a special __gen_path__, see if we have a gen_py as a
-# normal module and use that (ie, "win32com.gen_py" may already exist as
-# a package.
-if not __gen_path__:
-    try:
-        import win32com.gen_py
-
-        # __path__ is only ensured to be an Iterable, not a list.
-        __gen_path__ = next(iter(sys.modules["win32com.gen_py"].__path__))
-    except ImportError:
-        # If a win32com\gen_py directory already exists, then we use it
-        # (gencache doesn't insist it have an __init__, but our __import__
-        # above does!
-        __gen_path__ = os.path.abspath(os.path.join(__path__[0], "gen_py"))
-        if not os.path.isdir(__gen_path__):
-            # We used to dynamically create a directory under win32com -
-            # but this sucks.  If the dir doesn't already exist, we we
-            # create a version specific directory under the user temp
-            # directory.
-            __gen_path__ = os.path.join(
-                win32api.GetTempPath(),
-                "gen_py",
-                "%d.%d" % (sys.version_info.major, sys.version_info.minor),
-            )
-
-# we must have a __gen_path__, but may not have a gen_py module -
-# set that up.
-if "win32com.gen_py" not in sys.modules:
-    # Create a "win32com.gen_py", but with a custom __path__
-    import types
-
-    gen_py = types.ModuleType("win32com.gen_py")
-    gen_py.__path__ = [__gen_path__]
-    sys.modules[gen_py.__name__] = gen_py
-    del types
-gen_py = sys.modules["win32com.gen_py"]
-
-# get rid of these for module users
-del os, sys, win32api, pythoncom

py2docfx/venv/venv1/Lib/site-packages/win32com/client/CLSIDToClass.py

@@ -1,60 +0,0 @@
-"""Manages a dictionary of CLSID strings to Python classes.
-
-Primary use of this module is to allow modules generated by
-makepy.py to share classes.  @makepy@ automatically generates code
-which interacts with this module.  You should never need to reference
-this module directly.
-
-This module only provides support for modules which have been previously
-been imported.  The gencache module provides some support for loading modules
-on demand - once done, this module supports it...
-
-As an example, the MSACCESS.TLB type library makes reference to the
-CLSID of the Database object, as defined in DAO3032.DLL.  This
-allows code using the MSAccess wrapper to natively use Databases.
-
-This obviously applies to all cooperating objects, not just DAO and
-Access.
-"""
-
-from __future__ import annotations
-
-mapCLSIDToClass: dict[str, type] = {}
-
-
-def RegisterCLSID(clsid, pythonClass):
-    """Register a class that wraps a CLSID
-
-    This function allows a CLSID to be globally associated with a class.
-    Certain module will automatically convert an IDispatch object to an
-    instance of the associated class.
-    """
-
-    mapCLSIDToClass[str(clsid)] = pythonClass
-
-
-def RegisterCLSIDsFromDict(dict):
-    """Register a dictionary of CLSID's and classes.
-
-    This module performs the same function as @RegisterCLSID@, but for
-    an entire dictionary of associations.
-
-    Typically called by makepy generated modules at import time.
-    """
-    mapCLSIDToClass.update(dict)
-
-
-def GetClass(clsid):
-    """Given a CLSID, return the globally associated class.
-
-    clsid -- a string CLSID representation to check.
-    """
-    return mapCLSIDToClass[clsid]
-
-
-def HasClass(clsid):
-    """Determines if the CLSID has an associated class.
-
-    clsid -- the string CLSID to check
-    """
-    return clsid in mapCLSIDToClass