py2docfx 0.1.15.dev2025501__py3-none-any.whl → 0.1.15.dev2038808__py3-none-any.whl

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

@@ -1,229 +0,0 @@
-"""General Server side utilities"""
-
-import pythoncom
-import winerror
-
-from . import policy
-from .exception import COMException
-
-
-def wrap(ob, iid=None, usePolicy=None, useDispatcher=None):
-    """Wraps an object in a PyGDispatch gateway.
-
-    Returns a client side PyI{iid} interface.
-
-    Interface and gateway support must exist for the specified IID, as
-    the QueryInterface() method is used.
-
-    """
-    if usePolicy is None:
-        usePolicy = policy.DefaultPolicy
-    if useDispatcher == 1:  # True will also work here.
-        import win32com.server.dispatcher
-
-        useDispatcher = win32com.server.dispatcher.DefaultDebugDispatcher
-    if useDispatcher is None or useDispatcher == 0:
-        ob = usePolicy(ob)
-    else:
-        ob = useDispatcher(usePolicy, ob)
-
-    # get a PyIDispatch, which interfaces to PyGDispatch
-    ob = pythoncom.WrapObject(ob)
-    if iid is not None:
-        ob = ob.QueryInterface(iid)  # Ask the PyIDispatch if it supports it?
-    return ob
-
-
-def unwrap(ob):
-    """Unwraps an interface.
-
-    Given an interface which wraps up a Gateway, return the object behind
-    the gateway.
-    """
-    ob = pythoncom.UnwrapObject(ob)
-    # see if the object is a dispatcher
-    if hasattr(ob, "policy"):
-        ob = ob.policy
-    return ob._obj_
-
-
-class ListEnumerator:
-    """A class to expose a Python sequence as an EnumVARIANT.
-
-    Create an instance of this class passing a sequence (list, tuple, or
-    any sequence protocol supporting object) and it will automatically
-    support the EnumVARIANT interface for the object.
-
-    See also the @NewEnum@ function, which can be used to turn the
-    instance into an actual COM server.
-    """
-
-    _public_methods_ = ["Next", "Skip", "Reset", "Clone"]
-
-    def __init__(self, data, index=0, iid=pythoncom.IID_IEnumVARIANT):
-        self._list_ = data
-        self.index = index
-        self._iid_ = iid
-
-    def _query_interface_(self, iid):
-        if iid == self._iid_:
-            return 1
-
-    def Next(self, count):
-        result = self._list_[self.index : self.index + count]
-        self.Skip(count)
-        return result
-
-    def Skip(self, count):
-        end = self.index + count
-        if end > len(self._list_):
-            end = len(self._list_)
-        self.index = end
-
-    def Reset(self):
-        self.index = 0
-
-    def Clone(self):
-        return self._wrap(self.__class__(self._list_, self.index))
-
-    def _wrap(self, ob):
-        return wrap(ob)
-
-
-class ListEnumeratorGateway(ListEnumerator):
-    """A List Enumerator which wraps a sequence's items in gateways.
-
-    If a sequence contains items (objects) that have not been wrapped for
-    return through the COM layers, then a ListEnumeratorGateway can be
-    used to wrap those items before returning them (from the Next() method).
-
-    See also the @ListEnumerator@ class and the @NewEnum@ function.
-    """
-
-    def Next(self, count):
-        result = self._list_[self.index : self.index + count]
-        self.Skip(count)
-        return map(self._wrap, result)
-
-
-def NewEnum(
-    seq,
-    cls=ListEnumerator,
-    iid=pythoncom.IID_IEnumVARIANT,
-    usePolicy=None,
-    useDispatcher=None,
-):
-    """Creates a new enumerator COM server.
-
-    This function creates a new COM Server that implements the
-    IID_IEnumVARIANT interface.
-
-    A COM server that can enumerate the passed in sequence will be
-    created, then wrapped up for return through the COM framework.
-    Optionally, a custom COM server for enumeration can be passed
-    (the default is @ListEnumerator@), and the specific IEnum
-    interface can be specified.
-    """
-    ob = cls(seq, iid=iid)
-    return wrap(ob, iid, usePolicy=usePolicy, useDispatcher=useDispatcher)
-
-
-class Collection:
-    "A collection of VARIANT values."
-
-    _public_methods_ = ["Item", "Count", "Add", "Remove", "Insert"]
-
-    def __init__(self, data=None, readOnly=0):
-        if data is None:
-            data = []
-        self.data = data
-
-        # disable Add/Remove if read-only. note that we adjust _public_methods_
-        # on this instance only.
-        if readOnly:
-            self._public_methods_ = ["Item", "Count"]
-
-    # This method is also used as the "default" method.
-    # Thus "print(ob)" will cause this to be called with zero
-    # params.  Handle this slightly more elegantly here.
-    # Ideally the  policy should handle this.
-    def Item(self, *args):
-        if len(args) != 1:
-            raise COMException(scode=winerror.DISP_E_BADPARAMCOUNT)
-
-        try:
-            return self.data[args[0]]
-        except IndexError as desc:
-            raise COMException(scode=winerror.DISP_E_BADINDEX, desc=str(desc))
-
-    _value_ = Item
-
-    def Count(self):
-        return len(self.data)
-
-    def Add(self, value):
-        self.data.append(value)
-
-    def Remove(self, index):
-        try:
-            del self.data[index]
-        except IndexError as desc:
-            raise COMException(scode=winerror.DISP_E_BADINDEX, desc=str(desc))
-
-    def Insert(self, index, value):
-        try:
-            index = int(index)
-        except (ValueError, TypeError):
-            raise COMException(scode=winerror.DISP_E_TYPEMISMATCH)
-        self.data.insert(index, value)
-
-    def _NewEnum(self):
-        return NewEnum(self.data)
-
-
-def NewCollection(seq, cls=Collection):
-    """Creates a new COM collection object
-
-    This function creates a new COM Server that implements the
-    common collection protocols, including enumeration. (_NewEnum)
-
-    A COM server that can enumerate the passed in sequence will be
-    created, then wrapped up for return through the COM framework.
-    Optionally, a custom COM server for enumeration can be passed
-    (the default is @Collection@).
-    """
-    return pythoncom.WrapObject(
-        policy.DefaultPolicy(cls(seq)), pythoncom.IID_IDispatch, pythoncom.IID_IDispatch
-    )
-
-
-class FileStream:
-    _public_methods_ = ["Read", "Write", "Clone", "CopyTo", "Seek"]
-    _com_interfaces_ = [pythoncom.IID_IStream]
-
-    def __init__(self, file):
-        self.file = file
-
-    def Read(self, amount):
-        return self.file.read(amount)
-
-    def Write(self, data):
-        self.file.write(data)
-        return len(data)
-
-    def Clone(self):
-        return self._wrap(self.__class__(self.file))
-
-    def CopyTo(self, dest, cb):
-        data = self.file.read(cb)
-        cbread = len(data)
-        dest.Write(data)  ## ??? Write does not currently return the length ???
-        return cbread, cbread
-
-    def Seek(self, offset, origin):
-        # how convient that the 'origin' values are the same as the CRT :)
-        self.file.seek(offset, origin)
-        return self.file.tell()
-
-    def _wrap(self, ob):
-        return wrap(ob)

py2docfx/venv/venv1/Lib/site-packages/win32com/servers/PythonTools.py

@@ -1,47 +0,0 @@
-import sys
-import time
-
-
-class Tools:
-    _public_methods_ = ["reload", "adddir", "echo", "sleep"]
-
-    def reload(self, module):
-        if module in sys.modules:
-            from importlib import reload
-
-            reload(sys.modules[module])
-            return "reload succeeded."
-        return "no reload performed."
-
-    def adddir(self, dir):
-        if isinstance(dir, str):
-            sys.path.append(dir)
-        return str(sys.path)
-
-    def echo(self, arg):
-        return repr(arg)
-
-    def sleep(self, t):
-        time.sleep(t)
-
-
-if __name__ == "__main__":
-    from win32com.server.register import RegisterServer, UnregisterServer
-
-    clsid = "{06ce7630-1d81-11d0-ae37-c2fa70000000}"
-    progid = "Python.Tools"
-    verprogid = "Python.Tools.1"
-    if "--unregister" in sys.argv:
-        print("Unregistering...")
-        UnregisterServer(clsid, progid, verprogid)
-        print("Unregistered OK")
-    else:
-        print("Registering COM server...")
-        RegisterServer(
-            clsid,
-            "win32com.servers.PythonTools.Tools",
-            "Python Tools",
-            progid,
-            verprogid,
-        )
-        print("Class registered.")

py2docfx/venv/venv1/Lib/site-packages/win32com/servers/dictionary.py

@@ -1,133 +0,0 @@
-"""Python.Dictionary COM Server.
-
-This module implements a simple COM server that acts much like a Python
-dictionary or as a standard string-keyed VB Collection.  The keys of
-the dictionary are strings and are case-insensitive.
-
-It uses a highly customized policy to fine-tune the behavior exposed to
-the COM client.
-
-The object exposes the following properties:
-
-    int Count                       (readonly)
-    VARIANT Item(BSTR key)          (propget for Item)
-    Item(BSTR key, VARIANT value)   (propput for Item)
-
-    Note that 'Item' is the default property, so the following forms of
-    VB code are acceptable:
-
-        set ob = CreateObject("Python.Dictionary")
-        ob("hello") = "there"
-        ob.Item("hi") = ob("HELLO")
-
-All keys are defined, returning VT_NULL (None) if a value has not been
-stored.  To delete a key, simply assign VT_NULL to the key.
-
-The object responds to the _NewEnum method by returning an enumerator over
-the dictionary's keys. This allows for the following type of VB code:
-
-    for each name in ob
-        debug.print(name, ob(name))
-    next
-"""
-
-import pythoncom
-import pywintypes
-import winerror
-from pythoncom import DISPATCH_METHOD, DISPATCH_PROPERTYGET
-from win32com.server import policy, util
-from win32com.server.exception import COMException
-from winerror import S_OK
-
-
-class DictionaryPolicy(policy.BasicWrapPolicy):
-    ### BasicWrapPolicy looks for this
-    _com_interfaces_ = []
-
-    ### BasicWrapPolicy looks for this
-    _name_to_dispid_ = {
-        "item": pythoncom.DISPID_VALUE,
-        "_newenum": pythoncom.DISPID_NEWENUM,
-        "count": 1,
-    }
-
-    ### Auto-Registration process looks for these...
-    _reg_desc_ = "Python Dictionary"
-    _reg_clsid_ = "{39b61048-c755-11d0-86fa-00c04fc2e03e}"
-    _reg_progid_ = "Python.Dictionary"
-    _reg_verprogid_ = "Python.Dictionary.1"
-    _reg_policy_spec_ = "win32com.servers.dictionary.DictionaryPolicy"
-
-    def _CreateInstance_(self, clsid, reqIID):
-        self._wrap_({})
-        return pythoncom.WrapObject(self, reqIID)
-
-    def _wrap_(self, ob):
-        self._obj_ = ob  # ob should be a dictionary
-
-    def _invokeex_(self, dispid, lcid, wFlags, args, kwargs, serviceProvider):
-        if dispid == 0:  # item
-            l = len(args)
-            if l < 1:
-                raise COMException(
-                    desc="not enough parameters", scode=winerror.DISP_E_BADPARAMCOUNT
-                )
-
-            key = args[0]
-            if not isinstance(key, str):
-                ### the nArgErr thing should be 0-based, not reversed... sigh
-                raise COMException(
-                    desc="Key must be a string", scode=winerror.DISP_E_TYPEMISMATCH
-                )
-
-            key = key.lower()
-
-            if wFlags & (DISPATCH_METHOD | DISPATCH_PROPERTYGET):
-                if l > 1:
-                    raise COMException(scode=winerror.DISP_E_BADPARAMCOUNT)
-                return self._obj_.get(key)  # unknown keys return None (VT_NULL)
-
-            if l != 2:
-                raise COMException(scode=winerror.DISP_E_BADPARAMCOUNT)
-            if args[1] is None:
-                # delete a key when None is assigned to it
-                try:
-                    del self._obj_[key]
-                except KeyError:
-                    pass
-            else:
-                self._obj_[key] = args[1]
-            return S_OK
-
-        if dispid == 1:  # count
-            if not wFlags & DISPATCH_PROPERTYGET:
-                raise COMException(scode=winerror.DISP_E_MEMBERNOTFOUND)  # not found
-            if len(args) != 0:
-                raise COMException(scode=winerror.DISP_E_BADPARAMCOUNT)
-            return len(self._obj_)
-
-        if dispid == pythoncom.DISPID_NEWENUM:
-            return util.NewEnum(list(self._obj_))
-
-        raise COMException(scode=winerror.DISP_E_MEMBERNOTFOUND)
-
-    def _getidsofnames_(self, names, lcid):
-        ### this is a copy of MappedWrapPolicy._getidsofnames_ ...
-
-        name = names[0].lower()
-        try:
-            return (self._name_to_dispid_[name],)
-        except KeyError:
-            raise COMException(
-                scode=winerror.DISP_E_MEMBERNOTFOUND, desc="Member not found"
-            )
-
-
-def Register():
-    from win32com.server.register import UseCommandLine
-
-    return UseCommandLine(DictionaryPolicy)
-
-
-if __name__ == "__main__":
-    Register()

py2docfx/venv/venv1/Lib/site-packages/win32com/servers/interp.py

@@ -1,59 +0,0 @@
-"""Python.Interpreter COM Server
-
-This module implements a very very simple COM server which
-exposes the Python interpreter.
-
-This is designed more as a demonstration than a full blown COM server.
-General functionality and Error handling are both limited.
-
-To use this object, ensure it is registered by running this module
-from Python.exe.  Then, from Visual Basic, use "CreateObject('Python.Interpreter')",
-and call its methods!
-"""
-
-import winerror
-from win32com.server.exception import COMException
-
-
-# Expose the Python interpreter.
-class Interpreter:
-    """The interpreter object exposed via COM"""
-
-    _public_methods_ = ["Exec", "Eval"]
-    # All registration stuff to support fully automatic register/unregister
-    _reg_verprogid_ = "Python.Interpreter.2"
-    _reg_progid_ = "Python.Interpreter"
-    _reg_desc_ = "Python Interpreter"
-    _reg_clsid_ = "{30BD3490-2632-11cf-AD5B-524153480001}"
-    _reg_class_spec_ = "win32com.servers.interp.Interpreter"
-
-    def __init__(self):
-        self.dict = {}
-
-    def Eval(self, exp):
-        """Evaluate an expression."""
-        if not isinstance(exp, str):
-            raise COMException(
-                desc="Must be a string", scode=winerror.DISP_E_TYPEMISMATCH
-            )
-
-        return eval(str(exp), self.dict)
-
-    def Exec(self, exp):
-        """Execute a statement."""
-        if not isinstance(exp, str):
-            raise COMException(
-                desc="Must be a string", scode=winerror.DISP_E_TYPEMISMATCH
-            )
-        exec(str(exp), self.dict)
-
-
-def Register():
-    import win32com.server.register
-
-    return win32com.server.register.UseCommandLine(Interpreter)
-
-
-if __name__ == "__main__":
-    print("Registering COM server...")
-    Register()

py2docfx/venv/venv1/Lib/site-packages/win32com/servers/perfmon.py

@@ -1,36 +0,0 @@
-"""A COM Server which exposes the NT Performance monitor in a very rudimentary way
-
-Usage from VB:
-    set ob = CreateObject("Python.PerfmonQuery")
-    freeBytes = ob.Query("Memory", "Available Bytes")
-"""
-
-import pythoncom
-import win32pdhutil
-import winerror
-from win32com.server import register
-from win32com.server.exception import COMException
-
-
-class PerfMonQuery:
-    _reg_verprogid_ = "Python.PerfmonQuery.1"
-    _reg_progid_ = "Python.PerfmonQuery"
-    _reg_desc_ = "Python Performance Monitor query object"
-    _reg_clsid_ = "{64cef7a0-8ece-11d1-a65a-00aa00125a98}"
-    _reg_class_spec_ = "win32com.servers.perfmon.PerfMonQuery"
-    _public_methods_ = ["Query"]
-
-    def Query(self, object, counter, instance=None, machine=None):
-        try:
-            return win32pdhutil.GetPerformanceAttributes(
-                object, counter, instance, machine=machine
-            )
-        except win32pdhutil.error as exc:
-            raise COMException(desc=exc.strerror)
-        except TypeError as desc:
-            raise COMException(desc=desc, scode=winerror.DISP_E_TYPEMISMATCH)
-
-
-if __name__ == "__main__":
-    print("Registering COM server...")
-    register.UseCommandLine(PerfMonQuery)

py2docfx/venv/venv1/Lib/site-packages/win32com/servers/test_pycomtest.py

@@ -1,181 +0,0 @@
-# This is part of the Python test suite.
-# The object is registered when you first run the test suite.
-# (and hopefully unregistered once done ;-)
-
-import pythoncom
-import winerror
-
-# Ensure the vtables in the tlb are known.
-from win32com.client import constants, gencache
-from win32com.server.exception import COMException
-from win32com.server.util import wrap
-
-pythoncom.__future_currency__ = True
-# We use the constants from the module, so must insist on a gencache.
-# Otherwise, use of gencache is not necessary (tho still advised)
-gencache.EnsureModule("{6BCDCB60-5605-11D0-AE5F-CADD4C000000}", 0, 1, 1)
-
-
-class PyCOMTest:
-    _typelib_guid_ = "{6BCDCB60-5605-11D0-AE5F-CADD4C000000}"
-    _typelib_version = 1, 0
-    _com_interfaces_ = ["IPyCOMTest"]
-    _reg_clsid_ = "{e743d9cd-cb03-4b04-b516-11d3a81c1597}"
-    _reg_progid_ = "Python.Test.PyCOMTest"
-
-    def DoubleString(self, str):
-        return str * 2
-
-    def DoubleInOutString(self, str):
-        return str * 2
-
-    def Fire(self, nID):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def GetLastVarArgs(self):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def GetMultipleInterfaces(self, outinterface1, outinterface2):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def GetSafeArrays(self, attrs, attrs2, ints):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def GetSetDispatch(self, indisp):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    # Result is of type IPyCOMTest
-    def GetSetInterface(self, ininterface):
-        return wrap(self)
-
-    def GetSetVariant(self, indisp):
-        return indisp
-
-    def TestByRefVariant(self, v):
-        return v * 2
-
-    def TestByRefString(self, v):
-        return v * 2
-
-    # Result is of type IPyCOMTest
-    def GetSetInterfaceArray(self, ininterface):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def GetSetUnknown(self, inunk):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    # Result is of type ISimpleCounter
-    def GetSimpleCounter(self):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def GetSimpleSafeArray(self, ints):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def GetStruct(self):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def SetIntSafeArray(self, ints):
-        return len(ints)
-
-    def SetLongLongSafeArray(self, ints):
-        return len(ints)
-
-    def SetULongLongSafeArray(self, ints):
-        return len(ints)
-
-    def SetBinSafeArray(self, buf):
-        return len(buf)
-
-    def SetVarArgs(self, *args):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def SetVariantSafeArray(self, vars):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def Start(self):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def Stop(self, nID):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def StopAll(self):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def TakeByRefDispatch(self, inout):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def TakeByRefTypedDispatch(self, inout):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def Test(self, key, inval):
-        return not inval
-
-    def Test2(self, inval):
-        return inval
-
-    def Test3(self, inval):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def Test4(self, inval):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def Test5(self, inout):
-        if inout == constants.TestAttr1:
-            return constants.TestAttr1_1
-        elif inout == constants.TestAttr1_1:
-            return constants.TestAttr1
-        else:
-            return -1
-
-    def Test6(self, inval):
-        return inval
-
-    def TestInOut(self, fval, bval, lval):
-        return winerror.S_OK, fval * 2, not bval, lval * 2
-
-    def TestOptionals(self, strArg="def", sval=0, lval=1, dval=3.1400001049041748):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def TestOptionals2(self, dval, strval="", sval=1):
-        raise COMException(hresult=winerror.E_NOTIMPL)
-
-    def CheckVariantSafeArray(self, data):
-        return 1
-
-    def LongProp(self):
-        return self.longval
-
-    def SetLongProp(self, val):
-        self.longval = val
-
-    def ULongProp(self):
-        return self.ulongval
-
-    def SetULongProp(self, val):
-        self.ulongval = val
-
-    def IntProp(self):
-        return self.intval
-
-    def SetIntProp(self, val):
-        self.intval = val
-
-
-class PyCOMTestMI(PyCOMTest):
-    _typelib_guid_ = "{6BCDCB60-5605-11D0-AE5F-CADD4C000000}"
-    _typelib_version = 1, 0
-    # Interfaces with a interface name, a real IID, and an IID as a string
-    _com_interfaces_ = [
-        "IPyCOMTest",
-        pythoncom.IID_IStream,
-        str(pythoncom.IID_IStorage),
-    ]
-    _reg_clsid_ = "{F506E9A1-FB46-4238-A597-FA4EB69787CA}"
-    _reg_progid_ = "Python.Test.PyCOMTestMI"
-
-
-if __name__ == "__main__":
-    import win32com.server.register
-
-    win32com.server.register.UseCommandLine(PyCOMTest)
-    win32com.server.register.UseCommandLine(PyCOMTestMI)