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

py2docfx/venv/venv1/Lib/site-packages/win32comext/axdebug/codecontainer.py

@@ -1,279 +0,0 @@
-"""A utility class for a code container.
-
-A code container is a class which holds source code for a debugger.  It knows how
-to color the text, and also how to translate lines into offsets, and back.
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-import tokenize
-from keyword import kwlist
-from typing import Any
-
-import win32api
-import winerror
-from win32com.axdebug import axdebug, contexts
-from win32com.axdebug.util import _wrap
-from win32com.server.exception import COMException
-
-_keywords = {
-    _keyword
-    for _keyword in kwlist
-    # Avoids including True/False/None
-    if _keyword.islower()
-}
-"""set of Python keywords"""
-
-
-class SourceCodeContainer:
-    def __init__(
-        self,
-        text: str | None,
-        fileName="<Remove Me!>",
-        sourceContext=0,
-        startLineNumber=0,
-        site=None,
-        debugDocument=None,
-    ):
-        self.sourceContext = sourceContext  # The source context added by a smart host.
-        self.text: str | None = text
-        if text:
-            self._buildlines()
-        self.nextLineNo = 0
-        self.fileName = fileName
-        # Any: PyIDispatch type is not statically exposed
-        self.codeContexts: dict[int, Any] = {}
-        self.site = site
-        self.startLineNumber = startLineNumber
-        self.debugDocument = debugDocument
-
-    def _Close(self):
-        self.text = self.lines = self.lineOffsets = None
-        self.codeContexts = None
-        self.debugDocument = None
-        self.site = None
-        self.sourceContext = None
-
-    def GetText(self):
-        return self.text
-
-    def GetName(self, dnt):
-        raise NotImplementedError("You must subclass this")
-
-    def GetFileName(self):
-        return self.fileName
-
-    def GetPositionOfLine(self, cLineNumber):
-        self.GetText()  # Prime us.
-        try:
-            return self.lineOffsets[cLineNumber]
-        except IndexError:
-            raise COMException(scode=winerror.S_FALSE)
-
-    def GetLineOfPosition(self, charPos):
-        self.GetText()  # Prime us.
-        lastOffset = 0
-        lineNo = 0
-        for lineOffset in self.lineOffsets[1:]:
-            if lineOffset > charPos:
-                break
-            lastOffset = lineOffset
-            lineNo += 1
-        else:  # for not broken.
-            # print("Can't find", charPos, "in", self.lineOffsets)
-            raise COMException(scode=winerror.S_FALSE)
-        # print("GLOP ret=", lineNo, (charPos - lastOffset))
-        return lineNo, (charPos - lastOffset)
-
-    def GetNextLine(self):
-        if self.nextLineNo >= len(self.lines):
-            self.nextLineNo = 0  # auto-reset.
-            return ""
-        rc = self.lines[self.nextLineNo]
-        self.nextLineNo += 1
-        return rc
-
-    def GetLine(self, num):
-        self.GetText()  # Prime us.
-        return self.lines[num]
-
-    def GetNumChars(self):
-        return len(self.GetText())
-
-    def GetNumLines(self):
-        self.GetText()  # Prime us.
-        return len(self.lines)
-
-    def _buildline(self, pos):
-        i = self.text.find("\n", pos)
-        if i < 0:
-            newpos = len(self.text)
-        else:
-            newpos = i + 1
-        r = self.text[pos:newpos]
-        return r, newpos
-
-    def _buildlines(self):
-        self.lines = []
-        self.lineOffsets = [0]
-        line, pos = self._buildline(0)
-        while line:
-            self.lines.append(line)
-            self.lineOffsets.append(pos)
-            line, pos = self._buildline(pos)
-
-    def _ProcessToken(self, type, token, spos, epos, line):
-        srow, scol = spos
-        erow, ecol = epos
-        self.GetText()  # Prime us.
-        linenum = srow - 1  # Lines zero based for us too.
-        realCharPos = self.lineOffsets[linenum] + scol
-        numskipped = realCharPos - self.lastPos
-        if numskipped == 0:
-            pass
-        elif numskipped == 1:
-            self.attrs.append(axdebug.SOURCETEXT_ATTR_COMMENT)
-        else:
-            self.attrs.append((axdebug.SOURCETEXT_ATTR_COMMENT, numskipped))
-        kwSize = len(token)
-        self.lastPos = realCharPos + kwSize
-        attr = 0
-
-        if type == tokenize.NAME:
-            if token in _keywords:
-                attr = axdebug.SOURCETEXT_ATTR_KEYWORD
-        elif type == tokenize.STRING:
-            attr = axdebug.SOURCETEXT_ATTR_STRING
-        elif type == tokenize.NUMBER:
-            attr = axdebug.SOURCETEXT_ATTR_NUMBER
-        elif type == tokenize.OP:
-            attr = axdebug.SOURCETEXT_ATTR_OPERATOR
-        elif type == tokenize.COMMENT:
-            attr = axdebug.SOURCETEXT_ATTR_COMMENT
-        # else attr remains zero...
-        if kwSize == 0:
-            pass
-        elif kwSize == 1:
-            self.attrs.append(attr)
-        else:
-            self.attrs.append((attr, kwSize))
-
-    def GetSyntaxColorAttributes(self):
-        self.lastPos = 0
-        self.attrs = []
-        try:
-            for tokens in tokenize.tokenize(self.GetNextLine):
-                self._ProcessToken(*tokens)
-        except tokenize.TokenError:
-            pass  # Ignore - will cause all subsequent text to be commented.
-        numAtEnd = len(self.GetText()) - self.lastPos
-        if numAtEnd:
-            self.attrs.append((axdebug.SOURCETEXT_ATTR_COMMENT, numAtEnd))
-        return self.attrs
-
-    # We also provide and manage DebugDocumentContext objects
-    def _MakeDebugCodeContext(self, lineNo, charPos, len):
-        return _wrap(
-            contexts.DebugCodeContext(lineNo, charPos, len, self, self.site),
-            axdebug.IID_IDebugCodeContext,
-        )
-
-    # Make a context at the given position.  It should take up the entire context.
-    def _MakeContextAtPosition(self, charPos):
-        lineNo, offset = self.GetLineOfPosition(charPos)
-        try:
-            endPos = self.GetPositionOfLine(lineNo + 1)
-        except:
-            endPos = charPos
-        codecontext = self._MakeDebugCodeContext(lineNo, charPos, endPos - charPos)
-        return codecontext
-
-    # Returns a DebugCodeContext.  debugDocument can be None for smart hosts.
-    def GetCodeContextAtPosition(self, charPos):
-        # trace("GetContextOfPos", charPos, maxChars)
-        # Convert to line number.
-        lineNo, offset = self.GetLineOfPosition(charPos)
-        charPos = self.GetPositionOfLine(lineNo)
-        try:
-            cc = self.codeContexts[charPos]
-        except KeyError:
-            cc = self._MakeContextAtPosition(charPos)
-            self.codeContexts[charPos] = cc
-        return cc
-
-
-class SourceModuleContainer(SourceCodeContainer):
-    def __init__(self, module):
-        self.module = module
-        if hasattr(module, "__file__"):
-            fname = self.module.__file__
-            # Check for .pyc or .pyo or even .pys!
-            if fname[-1] in ["O", "o", "C", "c", "S", "s"]:
-                fname = fname[:-1]
-            try:
-                fname = win32api.GetFullPathName(fname)
-            except win32api.error:
-                pass
-        else:
-            if module.__name__ == "__main__" and len(sys.argv) > 0:
-                fname = sys.argv[0]
-            else:
-                fname = "<Unknown!>"
-        SourceCodeContainer.__init__(self, None, fname)
-
-    def GetText(self):
-        if self.text is None:
-            fname = self.GetFileName()
-            if fname:
-                try:
-                    self.text = open(fname, "r").read()
-                except OSError as details:
-                    self.text = f"# COMException opening file\n# {details!r}"
-            else:
-                self.text = f"# No file available for module '{self.module}'"
-            self._buildlines()
-        return self.text
-
-    def GetName(self, dnt):
-        name = self.module.__name__
-        try:
-            fname = win32api.GetFullPathName(self.module.__file__)
-        except win32api.error:
-            fname = self.module.__file__
-        except AttributeError:
-            fname = name
-        if dnt == axdebug.DOCUMENTNAMETYPE_APPNODE:
-            return name.split(".")[-1]
-        elif dnt == axdebug.DOCUMENTNAMETYPE_TITLE:
-            return fname
-        elif dnt == axdebug.DOCUMENTNAMETYPE_FILE_TAIL:
-            return os.path.split(fname)[1]
-        elif dnt == axdebug.DOCUMENTNAMETYPE_URL:
-            return f"file:{fname}"
-        else:
-            raise COMException(scode=winerror.E_UNEXPECTED)
-
-
-if __name__ == "__main__":
-    from Test import ttest
-
-    sc = SourceModuleContainer(ttest)
-    # sc = SourceCodeContainer(open(sys.argv[1], "rb").read(), sys.argv[1])
-    attrs = sc.GetSyntaxColorAttributes()
-    attrlen = 0
-    for attr in attrs:
-        if isinstance(attr, tuple):
-            attrlen += attr[1]
-        else:
-            attrlen += 1
-    text = sc.GetText()
-    if attrlen != len(text):
-        print(f"Lengths don't match!!! ({attrlen}/{len(text)})")
-
-    # print("Attributes:")
-    # print(attrs)
-    print("GetLineOfPos=", sc.GetLineOfPosition(0))
-    print("GetLineOfPos=", sc.GetLineOfPosition(4))
-    print("GetLineOfPos=", sc.GetLineOfPosition(10))

py2docfx/venv/venv1/Lib/site-packages/win32comext/axdebug/contexts.py

@@ -1,58 +0,0 @@
-"""A module for managing the AXDebug I*Contexts"""
-
-from . import adb, axdebug, gateways
-
-# Utility function for wrapping object created by this module.
-from .util import _wrap
-
-
-class DebugCodeContext(gateways.DebugCodeContext, gateways.DebugDocumentContext):
-    # NOTE: We also implement the IDebugDocumentContext interface for Simple Hosts.
-    # Thus, debugDocument may be NULL when we have smart hosts - but in that case, we
-    # won't be called upon to provide it.
-    _public_methods_ = (
-        gateways.DebugCodeContext._public_methods_
-        + gateways.DebugDocumentContext._public_methods_
-    )
-    _com_interfaces_ = (
-        gateways.DebugCodeContext._com_interfaces_
-        + gateways.DebugDocumentContext._com_interfaces_
-    )
-
-    def __init__(self, lineNo, charPos, len, codeContainer, debugSite):
-        self.debugSite = debugSite
-        self.offset = charPos
-        self.length = len
-        self.breakPointState = 0
-        self.lineno = lineNo
-        gateways.DebugCodeContext.__init__(self)
-        self.codeContainer = codeContainer
-
-    def _Close(self):
-        self.debugSite = None
-
-    def GetDocumentContext(self):
-        if self.debugSite is not None:
-            # We have a smart host - let him give it to us.
-            return self.debugSite.GetDocumentContextFromPosition(
-                self.codeContainer.sourceContext, self.offset, self.length
-            )
-        else:
-            # Simple host - Fine - I'll do it myself!
-            return _wrap(self, axdebug.IID_IDebugDocumentContext)
-
-    def SetBreakPoint(self, bps):
-        self.breakPointState = bps
-        adb.OnSetBreakPoint(self, bps, self.lineno)
-
-    # The DebugDocumentContext methods for simple hosts.
-    def GetDocument(self):
-        return self.codeContainer.debugDocument
-
-    def EnumCodeContexts(self):
-        return _wrap(EnumDebugCodeContexts([self]), axdebug.IID_IEnumDebugCodeContexts)
-
-
-class EnumDebugCodeContexts(gateways.EnumDebugCodeContexts):
-    def _wrap(self, obj):
-        return _wrap(obj, axdebug.IID_IDebugCodeContext)

py2docfx/venv/venv1/Lib/site-packages/win32comext/axdebug/debugger.py

@@ -1,238 +0,0 @@
-import os
-import sys
-
-import pythoncom
-from win32com.axdebug import adb, axdebug, codecontainer, documents, expressions
-from win32com.axdebug.util import _wrap
-
-currentDebugger = None
-
-
-class ModuleTreeNode:
-    """Helper class for building a module tree"""
-
-    def __init__(self, module):
-        modName = module.__name__
-        self.moduleName = modName
-        self.module = module
-        self.realNode = None
-        self.cont = codecontainer.SourceModuleContainer(module)
-
-    def __repr__(self):
-        return f"<ModuleTreeNode wrapping {self.module}>"
-
-    def Attach(self, parentRealNode):
-        self.realNode.Attach(parentRealNode)
-
-    def Close(self):
-        self.module = None
-        self.cont = None
-        self.realNode = None
-
-
-def BuildModule(module, built_nodes, rootNode, create_node_fn, create_node_args):
-    if module:
-        keep = module.__name__
-        keep = keep and (built_nodes.get(module) is None)
-        if keep and hasattr(module, "__file__"):
-            keep = os.path.splitext(module.__file__)[1].lower() not in [
-                ".pyd",
-                ".dll",
-            ]
-    # keep = keep and module.__name__=='__main__'
-    if module and keep:
-        # print("keeping", module.__name__)
-        node = ModuleTreeNode(module)
-        built_nodes[module] = node
-        realNode = create_node_fn(*(node,) + create_node_args)
-        node.realNode = realNode
-
-        # Split into parent nodes.
-        parts = module.__name__.split(".")
-        if parts[-1][:8] == "__init__":
-            parts = parts[:-1]
-        parent = ".".join(parts[:-1])
-        parentNode = rootNode
-        if parent:
-            parentModule = sys.modules[parent]
-            BuildModule(
-                parentModule, built_nodes, rootNode, create_node_fn, create_node_args
-            )
-            if parentModule in built_nodes:
-                parentNode = built_nodes[parentModule].realNode
-        node.Attach(parentNode)
-
-
-def RefreshAllModules(builtItems, rootNode, create_node, create_node_args):
-    for module in sys.modules.values():
-        BuildModule(module, builtItems, rootNode, create_node, create_node_args)
-
-
-# realNode = pdm.CreateDebugDocumentHelper(None) # DebugDocumentHelper node?
-# app.CreateApplicationNode() # doc provider node.
-
-
-class CodeContainerProvider(documents.CodeContainerProvider):
-    def __init__(self, axdebugger):
-        self.axdebugger = axdebugger
-        documents.CodeContainerProvider.__init__(self)
-        self.currentNumModules = len(sys.modules)
-        self.nodes = {}
-        self.axdebugger.RefreshAllModules(self.nodes, self)
-
-    def FromFileName(self, fname):
-        # It appears we can't add modules during a debug session!
-        # if self.currentNumModules != len(sys.modules):
-        #     self.axdebugger.RefreshAllModules(self.nodes, self)
-        #     self.currentNumModules = len(sys.modules)
-        # for key in self.ccsAndNodes:
-        #     print("File:", key)
-        return documents.CodeContainerProvider.FromFileName(self, fname)
-
-    def Close(self):
-        documents.CodeContainerProvider.Close(self)
-        self.axdebugger = None
-        print(f"Closing {len(self.nodes)} nodes")
-        for node in self.nodes.values():
-            node.Close()
-        self.nodes = {}
-
-
-class OriginalInterfaceMaker:
-    def MakeInterfaces(self, pdm):
-        app = self.pdm.CreateApplication()
-        self.cookie = pdm.AddApplication(app)
-        root = app.GetRootNode()
-        return app, root
-
-    def CloseInterfaces(self, pdm):
-        pdm.RemoveApplication(self.cookie)
-
-
-class SimpleHostStyleInterfaceMaker:
-    def MakeInterfaces(self, pdm):
-        app = pdm.GetDefaultApplication()
-        root = app.GetRootNode()
-        return app, root
-
-    def CloseInterfaces(self, pdm):
-        pass
-
-
-class AXDebugger:
-    def __init__(self, interfaceMaker=None, processName=None):
-        if processName is None:
-            processName = "Python Process"
-        if interfaceMaker is None:
-            interfaceMaker = SimpleHostStyleInterfaceMaker()
-
-        self.pydebugger = adb.Debugger()
-
-        self.pdm = pythoncom.CoCreateInstance(
-            axdebug.CLSID_ProcessDebugManager,
-            None,
-            pythoncom.CLSCTX_ALL,
-            axdebug.IID_IProcessDebugManager,
-        )
-
-        self.app, self.root = interfaceMaker.MakeInterfaces(self.pdm)
-        self.app.SetName(processName)
-        self.interfaceMaker = interfaceMaker
-
-        expressionProvider = _wrap(
-            expressions.ProvideExpressionContexts(),
-            axdebug.IID_IProvideExpressionContexts,
-        )
-        self.expressionCookie = self.app.AddGlobalExpressionContextProvider(
-            expressionProvider
-        )
-
-        contProvider = CodeContainerProvider(self)
-        self.pydebugger.AttachApp(self.app, contProvider)
-
-    def Break(self):
-        # Get the frame we start debugging from - this is the frame 1 level up
-        try:
-            1 + ""
-        except:
-            frame = sys.exc_info()[2].tb_frame.f_back
-
-        # Get/create the debugger, and tell it to break.
-        self.app.StartDebugSession()
-        # self.app.CauseBreak()
-
-        self.pydebugger.SetupAXDebugging(None, frame)
-        self.pydebugger.set_trace()
-
-    def Close(self):
-        self.pydebugger.ResetAXDebugging()
-        self.interfaceMaker.CloseInterfaces(self.pdm)
-        self.pydebugger.CloseApp()
-        self.app.RemoveGlobalExpressionContextProvider(self.expressionCookie)
-        self.expressionCookie = None
-
-        self.pdm = None
-        self.app = None
-        self.pydebugger = None
-        self.root = None
-
-    def RefreshAllModules(self, nodes, containerProvider):
-        RefreshAllModules(
-            nodes, self.root, self.CreateApplicationNode, (containerProvider,)
-        )
-
-    def CreateApplicationNode(self, node, containerProvider):
-        realNode = self.app.CreateApplicationNode()
-
-        document = documents.DebugDocumentText(node.cont)
-        document = _wrap(document, axdebug.IID_IDebugDocument)
-
-        node.cont.debugDocument = document
-
-        provider = documents.DebugDocumentProvider(document)
-        provider = _wrap(provider, axdebug.IID_IDebugDocumentProvider)
-        realNode.SetDocumentProvider(provider)
-
-        containerProvider.AddCodeContainer(node.cont, realNode)
-        return realNode
-
-
-def _GetCurrentDebugger():
-    global currentDebugger
-    if currentDebugger is None:
-        currentDebugger = AXDebugger()
-    return currentDebugger
-
-
-def Break():
-    _GetCurrentDebugger().Break()
-
-
-brk = Break
-set_trace = Break
-
-
-def dosomethingelse():
-    a = 2
-    b = "Hi there"
-
-
-def dosomething():
-    a = 1
-    b = 2
-    dosomethingelse()
-
-
-def test():
-    Break()
-    input("Waiting...")
-    dosomething()
-    print("Done")
-
-
-if __name__ == "__main__":
-    print("About to test the debugging interfaces!")
-    test()
-    print(
-        f" {pythoncom._GetInterfaceCount()}/{pythoncom._GetGatewayCount()} com objects still alive"
-    )

py2docfx/venv/venv1/Lib/site-packages/win32comext/axdebug/documents.py

@@ -1,135 +0,0 @@
-"""Management of documents for AXDebugging."""
-
-import pythoncom
-import win32api
-from win32com.server.util import unwrap
-
-from . import axdebug, gateways
-from .util import _wrap, trace
-
-# def trace(*args):
-#     pass
-
-
-def GetGoodFileName(fname):
-    if fname[0] != "<":
-        return win32api.GetFullPathName(fname)
-    return fname
-
-
-class DebugDocumentProvider(gateways.DebugDocumentProvider):
-    def __init__(self, doc):
-        self.doc = doc
-
-    def GetName(self, dnt):
-        return self.doc.GetName(dnt)
-
-    def GetDocumentClassId(self):
-        return self.doc.GetDocumentClassId()
-
-    def GetDocument(self):
-        return self.doc
-
-
-class DebugDocumentText(gateways.DebugDocumentText):
-    _com_interfaces_ = (
-        gateways.DebugDocumentInfo._com_interfaces_
-        + gateways.DebugDocumentText._com_interfaces_
-        + gateways.DebugDocument._com_interfaces_
-    )
-    _public_methods_ = (
-        gateways.DebugDocumentInfo._public_methods_
-        + gateways.DebugDocumentText._public_methods_
-        + gateways.DebugDocument._public_methods_
-    )
-
-    # A class which implements a DebugDocumentText, using the functionality
-    # provided by a codeContainer
-    def __init__(self, codeContainer):
-        gateways.DebugDocumentText.__init__(self)
-        gateways.DebugDocumentInfo.__init__(self)
-        gateways.DebugDocument.__init__(self)
-        self.codeContainer = codeContainer
-
-    def _Close(self):
-        self.docContexts = None
-        # self.codeContainer._Close()
-        self.codeContainer = None
-
-    # IDebugDocumentInfo
-    def GetName(self, dnt):
-        return self.codeContainer.GetName(dnt)
-
-    def GetDocumentClassId(self):
-        return "{DF630910-1C1D-11d0-AE36-8C0F5E000000}"
-
-    # IDebugDocument has no methods!
-    #
-
-    # IDebugDocumentText methods.
-    # def GetDocumentAttributes
-    def GetSize(self):
-        # trace("GetSize")
-        return self.codeContainer.GetNumLines(), self.codeContainer.GetNumChars()
-
-    def GetPositionOfLine(self, cLineNumber):
-        return self.codeContainer.GetPositionOfLine(cLineNumber)
-
-    def GetLineOfPosition(self, charPos):
-        return self.codeContainer.GetLineOfPosition(charPos)
-
-    def GetText(self, charPos, maxChars, wantAttr):
-        # Get all the attributes, else the tokenizer will get upset.
-        # XXX - not yet!
-        # trace("GetText", charPos, maxChars, wantAttr)
-        cont = self.codeContainer
-        attr = cont.GetSyntaxColorAttributes()
-        return cont.GetText(), attr
-
-    def GetPositionOfContext(self, context):
-        trace("GetPositionOfContext", context)
-        context = unwrap(context)
-        return context.offset, context.length
-
-    # Return a DebugDocumentContext.
-    def GetContextOfPosition(self, charPos, maxChars):
-        # Make one
-        doc = _wrap(self, axdebug.IID_IDebugDocument)
-        rc = self.codeContainer.GetCodeContextAtPosition(charPos)
-        return rc.QueryInterface(axdebug.IID_IDebugDocumentContext)
-
-
-class CodeContainerProvider:
-    """An abstract Python class which provides code containers!
-
-    Given a Python file name (as the debugger knows it by) this will
-    return a CodeContainer interface suitable for use.
-
-    This provides a simple base implementation that simply supports
-    a dictionary of nodes and providers.
-    """
-
-    def __init__(self):
-        self.ccsAndNodes = {}
-
-    def AddCodeContainer(self, cc, node=None):
-        fname = GetGoodFileName(cc.fileName)
-        self.ccsAndNodes[fname] = cc, node
-
-    def FromFileName(self, fname):
-        cc, node = self.ccsAndNodes.get(GetGoodFileName(fname), (None, None))
-        # if cc is None:
-        #     print(f"FromFileName for {fname} returning None")
-        return cc
-
-    def Close(self):
-        for cc, node in self.ccsAndNodes.values():
-            try:
-                # Must close the node before closing the provider
-                # as node may make calls on provider (eg Reset breakpoints etc)
-                if node is not None:
-                    node.Close()
-                cc._Close()
-            except pythoncom.com_error:
-                pass
-        self.ccsAndNodes = {}