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

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

@@ -1,70 +0,0 @@
-"""Constants used by COM Controls
-
-Hand created version of olectl.h constants.
-"""
-
-import winerror
-
-FACILITY_CONTROL = 0xA
-
-
-def MAKE_SCODE(sev, fac, code):
-    return int((int(-sev) << 31) | ((fac) << 16) | (code))
-
-
-def STD_CTL_SCODE(n):
-    return MAKE_SCODE(winerror.SEVERITY_ERROR, FACILITY_CONTROL, n)
-
-
-CTL_E_ILLEGALFUNCTIONCALL = STD_CTL_SCODE(5)
-CTL_E_OVERFLOW = STD_CTL_SCODE(6)
-CTL_E_OUTOFMEMORY = STD_CTL_SCODE(7)
-CTL_E_DIVISIONBYZERO = STD_CTL_SCODE(11)
-CTL_E_OUTOFSTRINGSPACE = STD_CTL_SCODE(14)
-CTL_E_OUTOFSTACKSPACE = STD_CTL_SCODE(28)
-CTL_E_BADFILENAMEORNUMBER = STD_CTL_SCODE(52)
-CTL_E_FILENOTFOUND = STD_CTL_SCODE(53)
-CTL_E_BADFILEMODE = STD_CTL_SCODE(54)
-CTL_E_FILEALREADYOPEN = STD_CTL_SCODE(55)
-CTL_E_DEVICEIOERROR = STD_CTL_SCODE(57)
-CTL_E_FILEALREADYEXISTS = STD_CTL_SCODE(58)
-CTL_E_BADRECORDLENGTH = STD_CTL_SCODE(59)
-CTL_E_DISKFULL = STD_CTL_SCODE(61)
-CTL_E_BADRECORDNUMBER = STD_CTL_SCODE(63)
-CTL_E_BADFILENAME = STD_CTL_SCODE(64)
-CTL_E_TOOMANYFILES = STD_CTL_SCODE(67)
-CTL_E_DEVICEUNAVAILABLE = STD_CTL_SCODE(68)
-CTL_E_PERMISSIONDENIED = STD_CTL_SCODE(70)
-CTL_E_DISKNOTREADY = STD_CTL_SCODE(71)
-CTL_E_PATHFILEACCESSERROR = STD_CTL_SCODE(75)
-CTL_E_PATHNOTFOUND = STD_CTL_SCODE(76)
-CTL_E_INVALIDPATTERNSTRING = STD_CTL_SCODE(93)
-CTL_E_INVALIDUSEOFNULL = STD_CTL_SCODE(94)
-CTL_E_INVALIDFILEFORMAT = STD_CTL_SCODE(321)
-CTL_E_INVALIDPROPERTYVALUE = STD_CTL_SCODE(380)
-CTL_E_INVALIDPROPERTYARRAYINDEX = STD_CTL_SCODE(381)
-CTL_E_SETNOTSUPPORTEDATRUNTIME = STD_CTL_SCODE(382)
-CTL_E_SETNOTSUPPORTED = STD_CTL_SCODE(383)
-CTL_E_NEEDPROPERTYARRAYINDEX = STD_CTL_SCODE(385)
-CTL_E_SETNOTPERMITTED = STD_CTL_SCODE(387)
-CTL_E_GETNOTSUPPORTEDATRUNTIME = STD_CTL_SCODE(393)
-CTL_E_GETNOTSUPPORTED = STD_CTL_SCODE(394)
-CTL_E_PROPERTYNOTFOUND = STD_CTL_SCODE(422)
-CTL_E_INVALIDCLIPBOARDFORMAT = STD_CTL_SCODE(460)
-CTL_E_INVALIDPICTURE = STD_CTL_SCODE(481)
-CTL_E_PRINTERERROR = STD_CTL_SCODE(482)
-CTL_E_CANTSAVEFILETOTEMP = STD_CTL_SCODE(735)
-CTL_E_SEARCHTEXTNOTFOUND = STD_CTL_SCODE(744)
-CTL_E_REPLACEMENTSTOOLONG = STD_CTL_SCODE(746)
-
-CONNECT_E_FIRST = MAKE_SCODE(winerror.SEVERITY_ERROR, winerror.FACILITY_ITF, 0x0200)
-CONNECT_E_LAST = MAKE_SCODE(winerror.SEVERITY_ERROR, winerror.FACILITY_ITF, 0x020F)
-CONNECT_S_FIRST = MAKE_SCODE(winerror.SEVERITY_SUCCESS, winerror.FACILITY_ITF, 0x0200)
-CONNECT_S_LAST = MAKE_SCODE(winerror.SEVERITY_SUCCESS, winerror.FACILITY_ITF, 0x020F)
-
-CONNECT_E_NOCONNECTION = CONNECT_E_FIRST + 0
-CONNECT_E_ADVISELIMIT = CONNECT_E_FIRST + 1
-CONNECT_E_CANNOTCONNECT = CONNECT_E_FIRST + 2
-CONNECT_E_OVERRIDDEN = CONNECT_E_FIRST + 3
-
-CLASS_E_NOTLICENSED = winerror.CLASSFACTORY_E_FIRST + 2

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

@@ -1 +0,0 @@
-# Empty __init__ file to designate a sub-package.

py2docfx/venv/venv1/Lib/site-packages/win32com/server/connect.py

@@ -1,85 +0,0 @@
-"""Utilities for Server Side connections.
-
-A collection of helpers for server side connection points.
-"""
-
-import pythoncom
-import win32com.server.util
-import winerror
-from win32com import olectl
-
-from .exception import COMException
-
-# Methods implemented by the interfaces.
-IConnectionPointContainer_methods = ["EnumConnectionPoints", "FindConnectionPoint"]
-IConnectionPoint_methods = [
-    "EnumConnections",
-    "Unadvise",
-    "Advise",
-    "GetConnectionPointContainer",
-    "GetConnectionInterface",
-]
-
-
-class ConnectableServer:
-    _public_methods_ = IConnectionPointContainer_methods + IConnectionPoint_methods
-    _com_interfaces_ = [
-        pythoncom.IID_IConnectionPoint,
-        pythoncom.IID_IConnectionPointContainer,
-    ]
-
-    # Clients must set _connect_interfaces_ = [...]
-    def __init__(self):
-        self.cookieNo = 0
-        self.connections = {}
-
-    # IConnectionPoint interfaces
-    def EnumConnections(self):
-        raise COMException(winerror.E_NOTIMPL)
-
-    def GetConnectionInterface(self):
-        raise COMException(winerror.E_NOTIMPL)
-
-    def GetConnectionPointContainer(self):
-        return win32com.server.util.wrap(self)
-
-    def Advise(self, pUnk):
-        # Creates a connection to the client.  Simply allocate a new cookie,
-        # find the clients interface, and store it in a dictionary.
-        try:
-            interface = pUnk.QueryInterface(
-                self._connect_interfaces_[0], pythoncom.IID_IDispatch
-            )
-        except pythoncom.com_error:
-            raise COMException(scode=olectl.CONNECT_E_NOCONNECTION)
-        self.cookieNo += 1
-        self.connections[self.cookieNo] = interface
-        return self.cookieNo
-
-    def Unadvise(self, cookie):
-        # Destroy a connection - simply delete interface from the map.
-        try:
-            del self.connections[cookie]
-        except KeyError:
-            raise COMException(scode=winerror.E_UNEXPECTED)
-
-    # IConnectionPointContainer interfaces
-    def EnumConnectionPoints(self):
-        raise COMException(winerror.E_NOTIMPL)
-
-    def FindConnectionPoint(self, iid):
-        # Find a connection we support.  Only support the single event interface.
-        if iid in self._connect_interfaces_:
-            return win32com.server.util.wrap(self)
-
-    def _BroadcastNotify(self, broadcaster, extraArgs):
-        # Broadcasts a notification to all connections.
-        # Ignores clients that fail.
-        for interface in self.connections.values():
-            try:
-                broadcaster(*(interface,) + extraArgs)
-            except pythoncom.com_error as details:
-                self._OnNotifyFail(interface, details)
-
-    def _OnNotifyFail(self, interface, details):
-        print(f"Ignoring COM error to connection - {details!r}")

py2docfx/venv/venv1/Lib/site-packages/win32com/server/dispatcher.py

@@ -1,239 +0,0 @@
-"""Dispatcher
-
-Please see policy.py for a discussion on dispatchers and policies
-"""
-
-from __future__ import annotations
-
-import traceback
-from typing import NoReturn
-
-import pythoncom
-import win32api
-import win32com
-from win32com.server.exception import IsCOMServerException
-from win32com.util import IIDToInterfaceName
-
-
-class DispatcherBase:
-    """The base class for all Dispatchers.
-
-    This dispatcher supports wrapping all operations in exception handlers,
-    and all the necessary delegation to the policy.
-
-    This base class supports the printing of "unexpected" exceptions.  Note, however,
-    that exactly where the output of print goes may not be useful!  A derived class may
-    provide additional semantics for this.
-    """
-
-    def __init__(self, policyClass, object):
-        self.policy = policyClass(object)
-        # The logger we should dump to.  If None, we should send to the
-        # default location (typically 'print')
-        self.logger = getattr(win32com, "logger", None)
-
-    def _CreateInstance_(self, clsid, reqIID):
-        try:
-            self.policy._CreateInstance_(clsid, reqIID)
-            return pythoncom.WrapObject(self, reqIID)
-        except:
-            self._HandleException_()
-
-    def _QueryInterface_(self, iid):
-        try:
-            return self.policy._QueryInterface_(iid)
-        except:
-            self._HandleException_()
-
-    def _Invoke_(self, dispid, lcid, wFlags, args):
-        try:
-            return self.policy._Invoke_(dispid, lcid, wFlags, args)
-        except:
-            self._HandleException_()
-
-    def _GetIDsOfNames_(self, names, lcid):
-        try:
-            return self.policy._GetIDsOfNames_(names, lcid)
-        except:
-            self._HandleException_()
-
-    def _GetTypeInfo_(self, index, lcid):
-        try:
-            return self.policy._GetTypeInfo_(index, lcid)
-        except:
-            self._HandleException_()
-
-    def _GetTypeInfoCount_(self):
-        try:
-            return self.policy._GetTypeInfoCount_()
-        except:
-            self._HandleException_()
-
-    def _GetDispID_(self, name, fdex):
-        try:
-            return self.policy._GetDispID_(name, fdex)
-        except:
-            self._HandleException_()
-
-    def _InvokeEx_(self, dispid, lcid, wFlags, args, kwargs, serviceProvider):
-        try:
-            return self.policy._InvokeEx_(
-                dispid, lcid, wFlags, args, kwargs, serviceProvider
-            )
-        except:
-            self._HandleException_()
-
-    def _DeleteMemberByName_(self, name, fdex):
-        try:
-            return self.policy._DeleteMemberByName_(name, fdex)
-        except:
-            self._HandleException_()
-
-    def _DeleteMemberByDispID_(self, id):
-        try:
-            return self.policy._DeleteMemberByDispID_(id)
-        except:
-            self._HandleException_()
-
-    def _GetMemberProperties_(self, id, fdex):
-        try:
-            return self.policy._GetMemberProperties_(id, fdex)
-        except:
-            self._HandleException_()
-
-    def _GetMemberName_(self, dispid):
-        try:
-            return self.policy._GetMemberName_(dispid)
-        except:
-            self._HandleException_()
-
-    def _GetNextDispID_(self, fdex, flags):
-        try:
-            return self.policy._GetNextDispID_(fdex, flags)
-        except:
-            self._HandleException_()
-
-    def _GetNameSpaceParent_(self):
-        try:
-            return self.policy._GetNameSpaceParent_()
-        except:
-            self._HandleException_()
-
-    def _HandleException_(self) -> NoReturn:
-        """Called whenever an exception is raised.
-
-        Default behaviour is to print the exception.
-        """
-        # If not a COM exception, print it for the developer.
-        if not IsCOMServerException():
-            if self.logger is not None:
-                self.logger.exception("pythoncom server error")
-            else:
-                traceback.print_exc()
-        # But still raise it for the framework.
-        raise
-
-    def _trace_(self, *args):
-        if self.logger is not None:
-            record = " ".join(map(str, args))
-            self.logger.debug(record)
-        else:
-            for arg in args[:-1]:
-                print(arg, end=" ")
-            print(args[-1])
-
-
-class DispatcherTrace(DispatcherBase):
-    """A dispatcher, which causes a 'print' line for each COM function called."""
-
-    def _QueryInterface_(self, iid):
-        rc = DispatcherBase._QueryInterface_(self, iid)
-        if not rc:
-            self._trace_(
-                "in {!r}._QueryInterface_ with unsupported IID {} ({})".format(
-                    self.policy._obj_, IIDToInterfaceName(iid), iid
-                )
-            )
-        return rc
-
-    def _GetIDsOfNames_(self, names, lcid):
-        self._trace_("in _GetIDsOfNames_ with '%s' and '%d'\n" % (names, lcid))
-        return DispatcherBase._GetIDsOfNames_(self, names, lcid)
-
-    def _GetTypeInfo_(self, index, lcid):
-        self._trace_("in _GetTypeInfo_ with index=%d, lcid=%d\n" % (index, lcid))
-        return DispatcherBase._GetTypeInfo_(self, index, lcid)
-
-    def _GetTypeInfoCount_(self):
-        self._trace_("in _GetTypeInfoCount_\n")
-        return DispatcherBase._GetTypeInfoCount_(self)
-
-    def _Invoke_(self, dispid, lcid, wFlags, args):
-        self._trace_("in _Invoke_ with", dispid, lcid, wFlags, args)
-        return DispatcherBase._Invoke_(self, dispid, lcid, wFlags, args)
-
-    def _GetDispID_(self, name, fdex):
-        self._trace_("in _GetDispID_ with", name, fdex)
-        return DispatcherBase._GetDispID_(self, name, fdex)
-
-    def _InvokeEx_(self, dispid, lcid, wFlags, args, kwargs, serviceProvider):
-        self._trace_(
-            "in {!r}._InvokeEx_-{}{!r} [{:x},{},{!r}]".format(
-                self.policy._obj_, dispid, args, wFlags, lcid, serviceProvider
-            )
-        )
-        return DispatcherBase._InvokeEx_(
-            self, dispid, lcid, wFlags, args, kwargs, serviceProvider
-        )
-
-    def _DeleteMemberByName_(self, name, fdex):
-        self._trace_("in _DeleteMemberByName_ with", name, fdex)
-        return DispatcherBase._DeleteMemberByName_(self, name, fdex)
-
-    def _DeleteMemberByDispID_(self, id):
-        self._trace_("in _DeleteMemberByDispID_ with", id)
-        return DispatcherBase._DeleteMemberByDispID_(self, id)
-
-    def _GetMemberProperties_(self, id, fdex):
-        self._trace_("in _GetMemberProperties_ with", id, fdex)
-        return DispatcherBase._GetMemberProperties_(self, id, fdex)
-
-    def _GetMemberName_(self, dispid):
-        self._trace_("in _GetMemberName_ with", dispid)
-        return DispatcherBase._GetMemberName_(self, dispid)
-
-    def _GetNextDispID_(self, fdex, flags):
-        self._trace_("in _GetNextDispID_ with", fdex, flags)
-        return DispatcherBase._GetNextDispID_(self, fdex, flags)
-
-    def _GetNameSpaceParent_(self):
-        self._trace_("in _GetNameSpaceParent_")
-        return DispatcherBase._GetNameSpaceParent_(self)
-
-
-class DispatcherWin32trace(DispatcherTrace):
-    """A tracing dispatcher that sends its output to the win32trace remote collector."""
-
-    def __init__(self, policyClass, object):
-        DispatcherTrace.__init__(self, policyClass, object)
-        if self.logger is None:
-            # If we have no logger, setup our output.
-            import win32traceutil  # Sets up everything.
-        self._trace_(f"Object with win32trace dispatcher created (object={object!r})")
-
-
-class DispatcherOutputDebugString(DispatcherTrace):
-    """A tracing dispatcher that sends its output to win32api.OutputDebugString"""
-
-    def _trace_(self, *args):
-        for arg in args[:-1]:
-            win32api.OutputDebugString(str(arg) + " ")
-        win32api.OutputDebugString(str(args[-1]) + "\n")
-
-
-try:
-    import win32trace  # nopycln: import # Check for win32traceutil w/o importing it
-
-    DefaultDebugDispatcher: type[DispatcherTrace] = DispatcherWin32trace
-except ImportError:  # no win32trace module - just use a print based one.
-    DefaultDebugDispatcher = DispatcherTrace

py2docfx/venv/venv1/Lib/site-packages/win32com/server/exception.py

@@ -1,99 +0,0 @@
-"""Exception Handling
-
-Exceptions
-
-    To better support COM exceptions, the framework allows for an instance to be
-    raised.  This instance may have a certain number of known attributes, which are
-    translated into COM exception details.
-
-    This means, for example, that Python could raise a COM exception that includes details
-    on a Help file and location, and a description for the user.
-
-    This module provides a class which provides the necessary attributes.
-"""
-
-import sys
-
-import pythoncom
-
-
-# Note that we derive from com_error, which derives from builtin Exception
-# Also note that we don't support "self.args", as we don't support tuple-unpacking
-class COMException(pythoncom.com_error):  # type: ignore[name-defined] # Dynamic module
-    """An Exception object that is understood by the framework.
-
-    If the framework is presented with an exception of type class,
-    it looks for certain known attributes on this class to provide rich
-    error information to the caller.
-
-    It should be noted that the framework supports providing this error
-    information via COM Exceptions, or via the ISupportErrorInfo interface.
-
-    By using this class, you automatically provide rich error information to the
-    server.
-    """
-
-    def __init__(
-        self,
-        description=None,
-        scode=None,
-        source=None,
-        helpfile=None,
-        helpContext=None,
-        desc=None,
-        hresult=None,
-    ):
-        """Initialize an exception
-        **Params**
-
-        description -- A string description for the exception.
-        scode -- An integer scode to be returned to the server, if necessary.
-        The pythoncom framework defaults this to be DISP_E_EXCEPTION if not specified otherwise.
-        source -- A string which identifies the source of the error.
-        helpfile -- A string which points to a help file which contains details on the error.
-        helpContext -- An integer context in the help file.
-        desc -- A short-cut for description.
-        hresult -- A short-cut for scode.
-        """
-
-        # convert a WIN32 error into an HRESULT
-        scode = scode or hresult
-        if scode and scode != 1:  # We don't want S_FALSE mapped!
-            if scode >= -32768 and scode < 32768:
-                # this is HRESULT_FROM_WIN32()
-                scode = -2147024896 | (scode & 0x0000FFFF)
-        self.scode = scode
-
-        self.description = description or desc
-        if scode == 1 and not self.description:
-            self.description = "S_FALSE"
-        elif scode and not self.description:
-            self.description = pythoncom.GetScodeString(scode)
-
-        self.source = source
-        self.helpfile = helpfile
-        self.helpcontext = helpContext
-
-        # todo - fill in the exception value
-        pythoncom.com_error.__init__(self, scode, self.description, None, -1)
-
-    def __repr__(self):
-        return f"<COM Exception - scode={self.scode}, desc={self.description}>"
-
-
-def IsCOMException(t=None):
-    if t is None:
-        t = sys.exc_info()[0]
-    if not t is type:
-        # t is not a class (likely None or a str)
-        return False
-    return issubclass(t, pythoncom.com_error)
-
-
-def IsCOMServerException(t=None):
-    if t is None:
-        t = sys.exc_info()[0]
-    if not t is type:
-        # t is not a class (likely None or a str)
-        return False
-    return issubclass(t, COMException)

py2docfx/venv/venv1/Lib/site-packages/win32com/server/factory.py

@@ -1,26 +0,0 @@
-# Class factory utilities.
-import pythoncom
-
-
-def RegisterClassFactories(clsids, flags=None, clsctx=None):
-    """Given a list of CLSID, create and register class factories.
-
-    Returns a list, which should be passed to RevokeClassFactories
-    """
-    if flags is None:
-        flags = pythoncom.REGCLS_MULTIPLEUSE | pythoncom.REGCLS_SUSPENDED
-    if clsctx is None:
-        clsctx = pythoncom.CLSCTX_LOCAL_SERVER
-    ret = []
-    for clsid in clsids:
-        # Some server append '-Embedding' etc
-        if clsid[0] not in ["-", "/"]:
-            factory = pythoncom.MakePyFactory(clsid)
-            regId = pythoncom.CoRegisterClassObject(clsid, factory, clsctx, flags)
-            ret.append((factory, regId))
-    return ret
-
-
-def RevokeClassFactories(infos):
-    for factory, revokeId in infos:
-        pythoncom.CoRevokeClassObject(revokeId)

py2docfx/venv/venv1/Lib/site-packages/win32com/server/localserver.py

@@ -1,53 +0,0 @@
-# LocalServer .EXE support for Python.
-#
-# This is designed to be used as a _script_ file by pythonw.exe
-#
-# In some cases, you could also use Python.exe, which will create
-# a console window useful for debugging.
-#
-# NOTE: When NOT running in any sort of debugging mode,
-# 'print' statements may fail, as sys.stdout is not valid!!!
-
-#
-# Usage:
-#  wpython.exe LocalServer.py clsid [, clsid]
-import sys
-
-sys.coinit_flags = 2
-import pythoncom
-import win32api
-from win32com.server import factory
-
-usage = """\
-Invalid command line arguments
-
-This program provides LocalServer COM support
-for Python COM objects.
-
-It is typically run automatically by COM, passing as arguments
-The ProgID or CLSID of the Python Server(s) to be hosted
-"""
-
-
-def serve(clsids):
-    infos = factory.RegisterClassFactories(clsids)
-
-    pythoncom.EnableQuitMessage(win32api.GetCurrentThreadId())
-    pythoncom.CoResumeClassObjects()
-
-    pythoncom.PumpMessages()
-
-    factory.RevokeClassFactories(infos)
-
-    pythoncom.CoUninitialize()
-
-
-def main():
-    if len(sys.argv) == 1:
-        win32api.MessageBox(0, usage, "Python COM Server")
-        sys.exit(1)
-    serve(sys.argv[1:])
-
-
-if __name__ == "__main__":
-    main()