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

py2docfx/venv/venv1/Lib/site-packages/win32com/test/util.py

@@ -1,262 +0,0 @@
-import logging
-import os
-import sys
-import tempfile
-import unittest
-import winreg
-
-import pythoncom
-import pywin32_testutil
-import pywintypes
-import win32api
-import win32com
-import winerror
-from pythoncom import _GetGatewayCount, _GetInterfaceCount
-
-
-def CheckClean():
-    # Ensure no lingering exceptions - Python should have zero outstanding
-    # COM objects
-    c = _GetInterfaceCount()
-    if c:
-        print("Warning - %d com interface objects still alive" % c)
-    c = _GetGatewayCount()
-    if c:
-        print("Warning - %d com gateway objects still alive" % c)
-
-
-def RegisterPythonServer(filename, progids=None, verbose=0):
-    if progids:
-        if isinstance(progids, str):
-            progids = [progids]
-        # we know the CLSIDs we need, but we might not be an admin user
-        # and otherwise unable to register them.  So as long as the progids
-        # exist and the DLL points at our version, assume it already is.
-        why_not = None
-        for progid in progids:
-            try:
-                clsid = pywintypes.IID(progid)
-            except pythoncom.com_error:
-                # not registered.
-                break
-            try:
-                HKCR = winreg.HKEY_CLASSES_ROOT
-                hk = winreg.OpenKey(HKCR, "CLSID\\%s" % clsid)
-                dll = winreg.QueryValue(hk, "InprocServer32")
-            except OSError:
-                # no CLSID or InProcServer32 - not registered
-                break
-            ok_files = [
-                os.path.basename(pythoncom.__file__),
-                "pythoncomloader%d%d.dll"
-                % (sys.version_info.major, sys.version_info.minor),
-            ]
-            if os.path.basename(dll) not in ok_files:
-                why_not = (
-                    "{!r} is registered against a different Python version ({})".format(
-                        progid,
-                        dll,
-                    )
-                )
-                break
-        else:
-            # print(f"Skipping registration of '{filename}' - already registered")
-            return
-    # needs registration - see if it's likely!
-    try:
-        from win32com.shell.shell import IsUserAnAdmin
-    except ImportError:
-        print("Can't import win32com.shell - no idea if you are an admin or not?")
-        is_admin = False
-    else:
-        try:
-            is_admin = IsUserAnAdmin()
-        except pythoncom.com_error:
-            # old, less-secure OS - assume *is* admin.
-            is_admin = True
-    if not is_admin:
-        msg = (
-            "%r isn't registered, but I'm not an administrator who can register it."
-            % progids[0]
-        )
-        if why_not:
-            msg += "\n(registration check failed as %s)" % why_not
-        # throw a normal "class not registered" exception - we don't report
-        # them the same way as "real" errors.
-        raise pythoncom.com_error(winerror.CO_E_CLASSSTRING, msg, None, -1)
-    # so theoretically we are able to register it.
-    cmd = f'{win32api.GetModuleFileName(0)} "{filename}" --unattended > nul 2>&1'
-    if verbose:
-        print("Registering engine", filename)
-        # print(cmd)
-    rc = os.system(cmd)
-    if rc:
-        print("Registration command was:")
-        print(cmd)
-        raise RuntimeError("Registration of engine '%s' failed" % filename)
-
-
-def ExecuteShellCommand(
-    cmd,
-    testcase,
-    expected_output=None,  # Set to '' to check for nothing
-    tracebacks_ok=0,  # OK if the output contains a t/b?
-):
-    output_name = tempfile.mktemp("win32com_test")
-    cmd += ' > "%s" 2>&1' % output_name
-    rc = os.system(cmd)
-    output = open(output_name, "r").read().strip()
-    os.remove(output_name)
-
-    class Failed(Exception):
-        pass
-
-    try:
-        if rc:
-            raise Failed("exit code was " + str(rc))
-        if expected_output is not None and output != expected_output:
-            raise Failed(f"Expected output {expected_output!r} (got {output!r})")
-        if not tracebacks_ok and output.find("Traceback (most recent call last)") >= 0:
-            raise Failed("traceback in program output")
-        return output
-    except Failed as why:
-        print("Failed to exec command '%r'" % cmd)
-        print("Failed as", why)
-        print("** start of program output **")
-        print(output)
-        print("** end of program output **")
-        testcase.fail(f"Executing '{cmd}' failed as {why}")
-
-
-def assertRaisesCOM_HRESULT(testcase, hresult, func, *args, **kw):
-    try:
-        func(*args, **kw)
-    except pythoncom.com_error as details:
-        if details.hresult == hresult:
-            return
-    testcase.fail("Excepected COM exception with HRESULT 0x%x" % hresult)
-
-
-class CaptureWriter:
-    def __init__(self):
-        self.old_err = self.old_out = None
-        self.clear()
-
-    def capture(self):
-        self.clear()
-        self.old_out = sys.stdout
-        self.old_err = sys.stderr
-        sys.stdout = sys.stderr = self
-
-    def release(self):
-        if self.old_out:
-            sys.stdout = self.old_out
-            self.old_out = None
-        if self.old_err:
-            sys.stderr = self.old_err
-            self.old_err = None
-
-    def clear(self):
-        self.captured = []
-
-    def write(self, msg):
-        self.captured.append(msg)
-
-    def get_captured(self):
-        return "".join(self.captured)
-
-    def get_num_lines_captured(self):
-        return len("".join(self.captured).split("\n"))
-
-
-# Utilities to set the win32com logger to something what just captures
-# records written and doesn't print them.
-class LogHandler(logging.Handler):
-    def __init__(self):
-        self.emitted = []
-        logging.Handler.__init__(self)
-
-    def emit(self, record):
-        self.emitted.append(record)
-
-
-_win32com_logger = None
-
-
-def setup_test_logger():
-    old_log = getattr(win32com, "logger", None)
-    global _win32com_logger
-    if _win32com_logger is None:
-        _win32com_logger = logging.Logger("test")
-        handler = LogHandler()
-        _win32com_logger.addHandler(handler)
-
-    win32com.logger = _win32com_logger
-    handler = _win32com_logger.handlers[0]
-    handler.emitted = []
-    return handler.emitted, old_log
-
-
-def restore_test_logger(prev_logger):
-    assert prev_logger is None, "who needs this?"
-    if prev_logger is None:
-        del win32com.logger
-    else:
-        win32com.logger = prev_logger
-
-
-# We used to override some of this (and may later!)
-TestCase = unittest.TestCase
-
-
-def CapturingFunctionTestCase(*args, **kw):
-    real_test = _CapturingFunctionTestCase(*args, **kw)
-    return pywin32_testutil.LeakTestCase(real_test)
-
-
-class _CapturingFunctionTestCase(unittest.FunctionTestCase):  # , TestCaseMixin):
-    def __call__(self, result=None):
-        if result is None:
-            result = self.defaultTestResult()
-        writer = CaptureWriter()
-        # self._preTest()
-        writer.capture()
-        try:
-            unittest.FunctionTestCase.__call__(self, result)
-            if getattr(self, "do_leak_tests", 0) and hasattr(sys, "gettotalrefcount"):
-                self.run_leak_tests(result)
-        finally:
-            writer.release()
-            # self._postTest(result)
-        output = writer.get_captured()
-        self.checkOutput(output, result)
-        if result.showAll:
-            print(output)
-
-    def checkOutput(self, output, result):
-        if output.find("Traceback") >= 0:
-            msg = "Test output contained a traceback\n---\n%s\n---" % output
-            result.errors.append((self, msg))
-
-
-class ShellTestCase(unittest.TestCase):
-    def __init__(self, cmd, expected_output):
-        self.__cmd = cmd
-        self.__eo = expected_output
-        unittest.TestCase.__init__(self)
-
-    def runTest(self):
-        ExecuteShellCommand(self.__cmd, self, self.__eo)
-
-    def __str__(self):
-        max = 30
-        if len(self.__cmd) > max:
-            cmd_repr = self.__cmd[:max] + "..."
-        else:
-            cmd_repr = self.__cmd
-        return "exec: " + cmd_repr
-
-
-def testmain(*args, **kw):
-    pywin32_testutil.testmain(*args, **kw)
-    CheckClean()

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

@@ -1,224 +0,0 @@
-# Code that packs and unpacks the Univgw structures.
-
-# See if we have a special directory for the binaries (for developers)
-
-import pythoncom
-from win32com.client import gencache
-
-com_error = pythoncom.com_error  # Re-exported alias
-
-
-def RegisterInterfaces(typelibGUID, lcid, major, minor, interface_names=None):
-    ret = []  # return a list of (dispid, funcname for our policy's benefit
-    # First see if we have makepy support.  If so, we can probably satisfy the request without loading the typelib.
-    try:
-        mod = gencache.GetModuleForTypelib(typelibGUID, lcid, major, minor)
-    except ImportError:
-        mod = None
-    if mod is None:
-        import win32com.client.build
-
-        # Load up the typelib and build (but don't cache) it now
-        tlb = pythoncom.LoadRegTypeLib(typelibGUID, major, minor, lcid)
-        typecomp_lib = tlb.GetTypeComp()
-        if interface_names is None:
-            interface_names = []
-            for i in range(tlb.GetTypeInfoCount()):
-                info = tlb.GetTypeInfo(i)
-                doc = tlb.GetDocumentation(i)
-                attr = info.GetTypeAttr()
-                if attr.typekind == pythoncom.TKIND_INTERFACE or (
-                    attr.typekind == pythoncom.TKIND_DISPATCH
-                    and attr.wTypeFlags & pythoncom.TYPEFLAG_FDUAL
-                ):
-                    interface_names.append(doc[0])
-        for name in interface_names:
-            type_info, type_comp = typecomp_lib.BindType(
-                name,
-            )
-            # Not sure why we don't get an exception here - BindType's C
-            # impl looks correct..
-            if type_info is None:
-                raise ValueError(f"The interface '{name}' can not be located")
-            # If we got back a Dispatch interface, convert to the real interface.
-            attr = type_info.GetTypeAttr()
-            if attr.typekind == pythoncom.TKIND_DISPATCH:
-                refhtype = type_info.GetRefTypeOfImplType(-1)
-                type_info = type_info.GetRefTypeInfo(refhtype)
-                attr = type_info.GetTypeAttr()
-            item = win32com.client.build.VTableItem(
-                type_info, attr, type_info.GetDocumentation(-1)
-            )
-            _doCreateVTable(
-                item.clsid, item.python_name, item.bIsDispatch, item.vtableFuncs
-            )
-            for info in item.vtableFuncs:
-                names, dispid, desc = info
-                invkind = desc[4]
-                ret.append((dispid, invkind, names[0]))
-    else:
-        # Cool - can used cached info.
-        for name in interface_names or mod.VTablesToClassMap.values():
-            try:
-                iid = mod.NamesToIIDMap[name]
-            except KeyError:
-                raise ValueError(
-                    f"Interface '{name}' does not exist in this cached typelib"
-                )
-            # print("Processing interface", name)
-            sub_mod = gencache.GetModuleForCLSID(iid)
-            is_dispatch = getattr(sub_mod, name + "_vtables_dispatch_", None)
-            method_defs = getattr(sub_mod, name + "_vtables_", None)
-            if is_dispatch is None or method_defs is None:
-                raise ValueError(f"Interface '{name}' is IDispatch only")
-
-            # And create the univgw defn
-            _doCreateVTable(iid, name, is_dispatch, method_defs)
-            for info in method_defs:
-                names, dispid, desc = info
-                invkind = desc[4]
-                ret.append((dispid, invkind, names[0]))
-    return ret
-
-
-def _doCreateVTable(iid, interface_name, is_dispatch, method_defs):
-    defn = Definition(iid, is_dispatch, method_defs)
-    vtbl = pythoncom._univgw.CreateVTable(defn, is_dispatch)
-    pythoncom._univgw.RegisterVTable(vtbl, iid, interface_name)
-
-
-def _CalcTypeSize(typeTuple):
-    t = typeTuple[0]
-    if t & (pythoncom.VT_BYREF | pythoncom.VT_ARRAY):
-        # It's a pointer.
-        cb = pythoncom._univgw.SizeOfVT(pythoncom.VT_PTR)[1]
-    elif t == pythoncom.VT_RECORD:
-        # Just because a type library uses records doesn't mean the user
-        # is trying to.  We need to better place to warn about this, but it
-        # isn't here.
-        # try:
-        #     import warnings
-        #     warnings.warn("warning: records are known to not work for vtable interfaces")
-        # except ImportError:
-        #     print("warning: records are known to not work for vtable interfaces")
-        cb = pythoncom._univgw.SizeOfVT(pythoncom.VT_PTR)[1]
-        # cb = typeInfo.GetTypeAttr().cbSizeInstance
-    else:
-        cb = pythoncom._univgw.SizeOfVT(t)[1]
-    return cb
-
-
-class Arg:
-    def __init__(self, arg_info, name=None):
-        self.name = name
-        self.vt, self.inOut, self.default, self.clsid = arg_info
-        self.size = _CalcTypeSize(arg_info)
-        # Offset from the beginning of the arguments of the stack.
-        self.offset = 0
-
-
-class Method:
-    def __init__(self, method_info, isEventSink=0):
-        all_names, dispid, desc = method_info
-        name = all_names[0]
-        names = all_names[1:]
-        invkind = desc[4]
-        arg_defs = desc[2]
-        ret_def = desc[8]
-
-        self.dispid = dispid
-        self.invkind = invkind
-        # We don't use this ATM.
-        #        self.ret = Arg(ret_def)
-        if isEventSink and name[:2] != "On":
-            name = "On%s" % name
-        self.name = name
-        cbArgs = 0
-        self.args = []
-        for argDesc in arg_defs:
-            arg = Arg(argDesc)
-            arg.offset = cbArgs
-            cbArgs += arg.size
-            self.args.append(arg)
-        self.cbArgs = cbArgs
-        self._gw_in_args = self._GenerateInArgTuple()
-        self._gw_out_args = self._GenerateOutArgTuple()
-
-    def _GenerateInArgTuple(self):
-        # Given a method, generate the in argument tuple
-        l = []
-        for arg in self.args:
-            if arg.inOut & pythoncom.PARAMFLAG_FIN or arg.inOut == 0:
-                l.append((arg.vt, arg.offset, arg.size))
-        return tuple(l)
-
-    def _GenerateOutArgTuple(self):
-        # Given a method, generate the out argument tuple
-        l = []
-        for arg in self.args:
-            if (
-                arg.inOut & pythoncom.PARAMFLAG_FOUT
-                or arg.inOut & pythoncom.PARAMFLAG_FRETVAL
-                or arg.inOut == 0
-            ):
-                l.append((arg.vt, arg.offset, arg.size, arg.clsid))
-        return tuple(l)
-
-
-class Definition:
-    def __init__(self, iid, is_dispatch, method_defs):
-        self._iid = iid
-        self._methods = []
-        self._is_dispatch = is_dispatch
-        for info in method_defs:
-            entry = Method(info)
-            self._methods.append(entry)
-
-    def iid(self):
-        return self._iid
-
-    def vtbl_argsizes(self):
-        return [m.cbArgs for m in self._methods]
-
-    def vtbl_argcounts(self):
-        return [len(m.args) for m in self._methods]
-
-    def dispatch(
-        self,
-        ob,
-        index,
-        argPtr,
-        ReadFromInTuple=pythoncom._univgw.ReadFromInTuple,
-        WriteFromOutTuple=pythoncom._univgw.WriteFromOutTuple,
-    ):
-        "Dispatch a call to an interface method."
-        meth = self._methods[index]
-        # Infer S_OK if they don't return anything bizarre.
-        hr = 0
-        args = ReadFromInTuple(meth._gw_in_args, argPtr)
-        # If ob is a dispatcher, ensure a policy
-        ob = getattr(ob, "policy", ob)
-        # Ensure the correct dispid is setup
-        ob._dispid_to_func_[meth.dispid] = meth.name
-        retVal = ob._InvokeEx_(meth.dispid, 0, meth.invkind, args, None, None)
-        # None is an allowed return value stating that
-        # the code doesn't want to touch any output arguments.
-        if isinstance(retVal, tuple):  # Like pythoncom, we special case a tuple.
-            # However, if they want to return a specific HRESULT,
-            # then they have to return all of the out arguments
-            # AND the HRESULT.
-            if len(retVal) == len(meth._gw_out_args) + 1:
-                hr = retVal[0]
-                retVal = retVal[1:]
-            else:
-                raise TypeError(
-                    "Expected {} return values, got: {}".format(
-                        len(meth._gw_out_args) + 1, len(retVal)
-                    )
-                )
-        else:
-            retVal = [retVal]
-            retVal.extend([None] * (len(meth._gw_out_args) - 1))
-            retVal = tuple(retVal)
-        WriteFromOutTuple(retVal, meth._gw_out_args, argPtr)
-        return hr

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

@@ -1,35 +0,0 @@
-"""General utility functions common to client and server.
-
-This module contains a collection of general purpose utility functions.
-"""
-
-import pythoncom
-import win32api
-import win32con
-
-
-def IIDToInterfaceName(iid):
-    """Converts an IID to a string interface name.
-
-    Used primarily for debugging purposes, this allows a cryptic IID to
-    be converted to a useful string name.  This will firstly look for interfaces
-    known (ie, registered) by pythoncom.  If not known, it will look in the
-    registry for a registered interface.
-
-    iid -- An IID object.
-
-    Result -- Always a string - either an interface name, or '<Unregistered interface>'
-    """
-    try:
-        return pythoncom.ServerInterfaces[iid]
-    except KeyError:
-        try:
-            try:
-                return win32api.RegQueryValue(
-                    win32con.HKEY_CLASSES_ROOT, "Interface\\%s" % iid
-                )
-            except win32api.error:
-                pass
-        except ImportError:
-            pass
-        return str(iid)

py2docfx/venv/venv1/Lib/site-packages/win32comext/adsi/__init__.py

@@ -1,113 +0,0 @@
-import win32com
-import win32com.client
-
-if isinstance(__path__, str):
-    # For freeze to work!
-    import sys
-
-    try:
-        import adsi
-
-        sys.modules["win32com.adsi.adsi"] = adsi
-    except ImportError:
-        pass
-else:
-    # See if we have a special directory for the binaries (for developers)
-    win32com.__PackageSupportBuildPath__(__path__)
-
-
-# Some helpers
-# We want to _look_ like the ADSI module, but provide some additional
-# helpers.
-
-# Of specific note - most of the interfaces supported by ADSI
-# derive from IDispatch - thus, you get the custome methods from the
-# interface, as well as via IDispatch.
-import pythoncom
-
-from .adsi import *  # nopycln: import # Re-export everything from win32comext/adsi/adsi.pyd
-
-LCID = 0
-
-IDispatchType = pythoncom.TypeIIDs[pythoncom.IID_IDispatch]
-IADsContainerType = pythoncom.TypeIIDs[adsi.IID_IADsContainer]
-
-
-def _get_good_ret(
-    ob,
-    # Named arguments used internally
-    resultCLSID=None,
-):
-    assert resultCLSID is None, "Now have type info for ADSI objects - fix me!"
-    # See if the object supports IDispatch
-    if hasattr(ob, "Invoke"):
-        import win32com.client.dynamic
-
-        name = "Dispatch wrapper around %r" % ob
-        return win32com.client.dynamic.Dispatch(ob, name, ADSIDispatch)
-    return ob
-
-
-class ADSIEnumerator:
-    def __init__(self, ob):
-        # Query the object for the container interface.
-        self._cont_ = ob.QueryInterface(adsi.IID_IADsContainer)
-        self._oleobj_ = adsi.ADsBuildEnumerator(self._cont_)  # a PyIADsEnumVARIANT
-        self.index = -1
-
-    def __getitem__(self, index):
-        return self.__GetIndex(index)
-
-    def __call__(self, index):
-        return self.__GetIndex(index)
-
-    def __GetIndex(self, index):
-        if not isinstance(index, int):
-            raise TypeError("Only integer indexes are supported for enumerators")
-        if index != self.index + 1:
-            # Index requested out of sequence.
-            raise ValueError("You must index this object sequentially")
-        self.index = index
-        result = adsi.ADsEnumerateNext(self._oleobj_, 1)
-        if len(result):
-            return _get_good_ret(result[0])
-        # Failed - reset for next time around.
-        self.index = -1
-        self._oleobj_ = adsi.ADsBuildEnumerator(self._cont_)  # a PyIADsEnumVARIANT
-        raise IndexError("list index out of range")
-
-
-class ADSIDispatch(win32com.client.CDispatch):
-    def _wrap_dispatch_(self, ob, userName=None, returnCLSID=None):
-        if not userName:
-            userName = "ADSI-object"
-        olerepr = win32com.client.dynamic.MakeOleRepr(ob, None, None)
-        return ADSIDispatch(ob, olerepr, userName)
-
-    def _NewEnum(self):
-        try:
-            return ADSIEnumerator(self)
-        except pythoncom.com_error:
-            # doesn't support it - let our base try!
-            return win32com.client.CDispatch._NewEnum(self)
-
-    def __getattr__(self, attr):
-        try:
-            return getattr(self._oleobj_, attr)
-        except AttributeError:
-            return win32com.client.CDispatch.__getattr__(self, attr)
-
-    def QueryInterface(self, iid):
-        ret = self._oleobj_.QueryInterface(iid)
-        return _get_good_ret(ret)
-
-
-# We override the adsi.pyd methods to do the right thing.
-def ADsGetObject(path, iid=pythoncom.IID_IDispatch):
-    ret = adsi.ADsGetObject(path, iid)
-    return _get_good_ret(ret)
-
-
-def ADsOpenObject(path, username, password, reserved=0, iid=pythoncom.IID_IDispatch):
-    ret = adsi.ADsOpenObject(path, username, password, reserved, iid)
-    return _get_good_ret(ret)