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

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/idle/CallTips.py

@@ -1,216 +0,0 @@
-# CallTips.py - An IDLE extension that provides "Call Tips" - ie, a floating window that
-# displays parameter information as you open parens.
-
-import inspect
-import string
-import sys
-import traceback
-
-
-class CallTips:
-    menudefs = []
-
-    keydefs = {
-        "<<paren-open>>": ["<Key-parenleft>"],
-        "<<paren-close>>": ["<Key-parenright>"],
-        "<<check-calltip-cancel>>": ["<KeyRelease>"],
-        "<<calltip-cancel>>": ["<ButtonPress>", "<Key-Escape>"],
-    }
-
-    windows_keydefs = {}
-
-    unix_keydefs = {}
-
-    def __init__(self, editwin):
-        self.editwin = editwin
-        self.text = editwin.text
-        self.calltip = None
-        if hasattr(self.text, "make_calltip_window"):
-            self._make_calltip_window = self.text.make_calltip_window
-        else:
-            self._make_calltip_window = self._make_tk_calltip_window
-
-    def close(self):
-        self._make_calltip_window = None
-
-    # Makes a Tk based calltip window.  Used by IDLE, but not Pythonwin.
-    # See __init__ above for how this is used.
-    def _make_tk_calltip_window(self):
-        import CallTipWindow
-
-        return CallTipWindow.CallTip(self.text)
-
-    def _remove_calltip_window(self):
-        if self.calltip:
-            self.calltip.hidetip()
-            self.calltip = None
-
-    def paren_open_event(self, event):
-        self._remove_calltip_window()
-        arg_text = get_arg_text(self.get_object_at_cursor())
-        if arg_text:
-            self.calltip_start = self.text.index("insert")
-            self.calltip = self._make_calltip_window()
-            self.calltip.showtip(arg_text)
-        return ""  # so the event is handled normally.
-
-    def paren_close_event(self, event):
-        # Now just hides, but later we should check if other
-        # paren'd expressions remain open.
-        self._remove_calltip_window()
-        return ""  # so the event is handled normally.
-
-    def check_calltip_cancel_event(self, event):
-        if self.calltip:
-            # If we have moved before the start of the calltip,
-            # or off the calltip line, then cancel the tip.
-            # (Later need to be smarter about multi-line, etc)
-            if self.text.compare(
-                "insert", "<=", self.calltip_start
-            ) or self.text.compare("insert", ">", self.calltip_start + " lineend"):
-                self._remove_calltip_window()
-        return ""  # so the event is handled normally.
-
-    def calltip_cancel_event(self, event):
-        self._remove_calltip_window()
-        return ""  # so the event is handled normally.
-
-    def get_object_at_cursor(
-        self,
-        wordchars="._"
-        + string.ascii_uppercase
-        + string.ascii_lowercase
-        + string.digits,
-    ):
-        # XXX - This needs to be moved to a better place
-        # so the "." attribute lookup code can also use it.
-        text = self.text
-        chars = text.get("insert linestart", "insert")
-        i = len(chars)
-        while i and chars[i - 1] in wordchars:
-            i -= 1
-        word = chars[i:]
-        if word:
-            # How is this for a hack!
-            import __main__
-
-            namespace = sys.modules.copy()
-            namespace.update(__main__.__dict__)
-            try:
-                return eval(word, namespace)
-            except:
-                pass
-        return None  # Can't find an object.
-
-
-def _find_constructor(class_ob):
-    # Given a class object, return a function object used for the
-    # constructor (ie, __init__() ) or None if we can't find one.
-    try:
-        return class_ob.__init__
-    except AttributeError:
-        for base in class_ob.__bases__:
-            rc = _find_constructor(base)
-            if rc is not None:
-                return rc
-    return None
-
-
-def get_arg_text(ob):
-    # Get a string describing the arguments for the given object.
-    argText = ""
-    if ob is not None:
-        if inspect.isclass(ob):
-            # Look for the highest __init__ in the class chain.
-            fob = _find_constructor(ob)
-            if fob is None:
-                fob = lambda: None
-        else:
-            fob = ob
-        if inspect.isfunction(fob) or inspect.ismethod(fob):
-            try:
-                argText = str(inspect.signature(fob))
-            except:
-                print("Failed to format the args")
-                traceback.print_exc()
-        # See if we can use the docstring
-        if hasattr(ob, "__doc__"):
-            doc = ob.__doc__
-            try:
-                doc = doc.strip()
-                pos = doc.find("\n")
-            except AttributeError:
-                ## New style classes may have __doc__ slot without actually
-                ## having a string assigned to it
-                pass
-            else:
-                if pos < 0 or pos > 70:
-                    pos = 70
-                if argText:
-                    argText += "\n"
-                argText += doc[:pos]
-
-    return argText
-
-
-#################################################
-#
-# Test code
-#
-if __name__ == "__main__":
-
-    def t1():
-        "()"
-
-    def t2(a, b=None):
-        "(a, b=None)"
-
-    def t3(a, *args):
-        "(a, *args)"
-
-    def t4(*args):
-        "(*args)"
-
-    def t5(a, *args):
-        "(a, *args)"
-
-    def t6(a, b=None, *args, **kw):
-        "(a, b=None, *args, **kw)"
-
-    class TC:
-        "(self, a=None, *b)"
-
-        def __init__(self, a=None, *b):
-            "(self, a=None, *b)"
-
-        def t1(self):
-            "(self)"
-
-        def t2(self, a, b=None):
-            "(self, a, b=None)"
-
-        def t3(self, a, *args):
-            "(self, a, *args)"
-
-        def t4(self, *args):
-            "(self, *args)"
-
-        def t5(self, a, *args):
-            "(self, a, *args)"
-
-        def t6(self, a, b=None, *args, **kw):
-            "(self, a, b=None, *args, **kw)"
-
-    def test(tests):
-        failed = []
-        for t in tests:
-            expected = t.__doc__ + "\n" + t.__doc__
-            if get_arg_text(t) != expected:
-                failed.append(t)
-                print(f"{t} - expected {expected!r}, but got {get_arg_text(t)!r}")
-        print("%d of %d tests failed" % (len(failed), len(tests)))
-
-    tc = TC()
-    tests = t1, t2, t3, t4, t5, t6, TC, tc.t1, tc.t2, tc.t3, tc.t4, tc.t5, tc.t6
-
-    test(tests)

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/idle/FormatParagraph.py

@@ -1,166 +0,0 @@
-# Extension to format a paragraph
-
-# Does basic, standard text formatting, and also understands Python
-# comment blocks.  Thus, for editing Python source code, this
-# extension is really only suitable for reformatting these comment
-# blocks or triple-quoted strings.
-
-# Known problems with comment reformatting:
-# * If there is a selection marked, and the first line of the
-#   selection is not complete, the block will probably not be detected
-#   as comments, and will have the normal "text formatting" rules
-#   applied.
-# * If a comment block has leading whitespace that mixes tabs and
-#   spaces, they will not be considered part of the same block.
-# * Fancy comments, like this bulleted list, aren't handled :-)
-
-import re
-
-
-class FormatParagraph:
-    menudefs = [
-        (
-            "edit",
-            [
-                ("Format Paragraph", "<<format-paragraph>>"),
-            ],
-        )
-    ]
-
-    keydefs = {
-        "<<format-paragraph>>": ["<Alt-q>"],
-    }
-
-    unix_keydefs = {
-        "<<format-paragraph>>": ["<Meta-q>"],
-    }
-
-    def __init__(self, editwin):
-        self.editwin = editwin
-
-    def close(self):
-        self.editwin = None
-
-    def format_paragraph_event(self, event):
-        text = self.editwin.text
-        first, last = self.editwin.get_selection_indices()
-        if first and last:
-            data = text.get(first, last)
-            comment_header = ""
-        else:
-            first, last, comment_header, data = find_paragraph(
-                text, text.index("insert")
-            )
-        if comment_header:
-            # Reformat the comment lines - convert to text sans header.
-            lines = data.split("\n")
-            lines = map(lambda st, l=len(comment_header): st[l:], lines)
-            data = "\n".join(lines)
-            # Reformat to 70 chars or a 20 char width, whichever is greater.
-            format_width = max(70 - len(comment_header), 20)
-            newdata = reformat_paragraph(data, format_width)
-            # re-split and re-insert the comment header.
-            newdata = newdata.split("\n")
-            # If the block ends in a \n, we don't want the comment
-            # prefix inserted after it. (I'm not sure it makes sense to
-            # reformat a comment block that isn't made of complete
-            # lines, but whatever!)  Can't think of a clean soltution,
-            # so we hack away
-            block_suffix = ""
-            if not newdata[-1]:
-                block_suffix = "\n"
-                newdata = newdata[:-1]
-            builder = lambda item, prefix=comment_header: prefix + item
-            newdata = "\n".join([builder(d) for d in newdata]) + block_suffix
-        else:
-            # Just a normal text format
-            newdata = reformat_paragraph(data)
-        text.tag_remove("sel", "1.0", "end")
-        if newdata != data:
-            text.mark_set("insert", first)
-            text.undo_block_start()
-            text.delete(first, last)
-            text.insert(first, newdata)
-            text.undo_block_stop()
-        else:
-            text.mark_set("insert", last)
-        text.see("insert")
-
-
-def find_paragraph(text, mark):
-    lineno, col = list(map(int, mark.split(".")))
-    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
-    while text.compare("%d.0" % lineno, "<", "end") and is_all_white(line):
-        lineno += 1
-        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
-    first_lineno = lineno
-    comment_header = get_comment_header(line)
-    comment_header_len = len(comment_header)
-    while get_comment_header(line) == comment_header and not is_all_white(
-        line[comment_header_len:]
-    ):
-        lineno += 1
-        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
-    last = "%d.0" % lineno
-    # Search back to beginning of paragraph
-    lineno = first_lineno - 1
-    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
-    while (
-        lineno > 0
-        and get_comment_header(line) == comment_header
-        and not is_all_white(line[comment_header_len:])
-    ):
-        lineno -= 1
-        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
-    first = "%d.0" % (lineno + 1)
-    return first, last, comment_header, text.get(first, last)
-
-
-def reformat_paragraph(data, limit=70):
-    lines = data.split("\n")
-    i = 0
-    n = len(lines)
-    while i < n and is_all_white(lines[i]):
-        i += 1
-    if i >= n:
-        return data
-    indent1 = get_indent(lines[i])
-    if i + 1 < n and not is_all_white(lines[i + 1]):
-        indent2 = get_indent(lines[i + 1])
-    else:
-        indent2 = indent1
-    new = lines[:i]
-    partial = indent1
-    while i < n and not is_all_white(lines[i]):
-        # XXX Should take double space after period (etc.) into account
-        words = re.split(r"(\s+)", lines[i])
-        for j in range(0, len(words), 2):
-            word = words[j]
-            if not word:
-                continue  # Can happen when line ends in whitespace
-            if len((partial + word).expandtabs()) > limit and partial != indent1:
-                new.append(partial.rstrip())
-                partial = indent2
-            partial += word + " "
-            if j + 1 < len(words) and words[j + 1] != " ":
-                partial += " "
-        i += 1
-    new.append(partial.rstrip())
-    # XXX Should reformat remaining paragraphs as well
-    new.extend(lines[i:])
-    return "\n".join(new)
-
-
-def is_all_white(line):
-    return re.match(r"^\s*$", line) is not None
-
-
-def get_indent(line):
-    return re.match(r"^(\s*)", line).group()
-
-
-def get_comment_header(line):
-    m = re.match(r"^(\s*#*)", line)
-    if m is None:
-        return ""
-    return m.group(1)

py2docfx/venv/venv1/Lib/site-packages/pythonwin/pywin/idle/IdleHistory.py

@@ -1,87 +0,0 @@
-class History:
-    def __init__(self, text, output_sep="\n"):
-        self.text = text
-        self.history = []
-        self.history_prefix = None
-        self.history_pointer = None
-        self.output_sep = output_sep
-        text.bind("<<history-previous>>", self.history_prev)
-        text.bind("<<history-next>>", self.history_next)
-
-    def history_next(self, event):
-        self.history_do(0)
-        return "break"
-
-    def history_prev(self, event):
-        self.history_do(1)
-        return "break"
-
-    def _get_source(self, start, end):
-        # Get source code from start index to end index.  Lines in the
-        # text control may be separated by sys.ps2 .
-        lines = self.text.get(start, end).split(self.output_sep)
-        return "\n".join(lines)
-
-    def _put_source(self, where, source):
-        output = self.output_sep.join(source.split("\n"))
-        self.text.insert(where, output)
-
-    def history_do(self, reverse):
-        nhist = len(self.history)
-        pointer = self.history_pointer
-        prefix = self.history_prefix
-        if pointer is not None and prefix is not None:
-            if (
-                self.text.compare("insert", "!=", "end-1c")
-                or self._get_source("iomark", "end-1c") != self.history[pointer]
-            ):
-                pointer = prefix = None
-        if pointer is None or prefix is None:
-            prefix = self._get_source("iomark", "end-1c")
-            if reverse:
-                pointer = nhist
-            else:
-                pointer = -1
-        nprefix = len(prefix)
-        while 1:
-            if reverse:
-                pointer -= 1
-            else:
-                pointer += 1
-            if pointer < 0 or pointer >= nhist:
-                self.text.bell()
-                if self._get_source("iomark", "end-1c") != prefix:
-                    self.text.delete("iomark", "end-1c")
-                    self._put_source("iomark", prefix)
-                pointer = prefix = None
-                break
-            item = self.history[pointer]
-            if item[:nprefix] == prefix and len(item) > nprefix:
-                self.text.delete("iomark", "end-1c")
-                self._put_source("iomark", item)
-                break
-        self.text.mark_set("insert", "end-1c")
-        self.text.see("insert")
-        self.text.tag_remove("sel", "1.0", "end")
-        self.history_pointer = pointer
-        self.history_prefix = prefix
-
-    def history_store(self, source):
-        source = source.strip()
-        if len(source) > 2:
-            # avoid duplicates
-            try:
-                self.history.remove(source)
-            except ValueError:
-                pass
-            self.history.append(source)
-        self.history_pointer = None
-        self.history_prefix = None
-
-    def recall(self, s):
-        s = s.strip()
-        self.text.tag_remove("sel", "1.0", "end")
-        self.text.delete("iomark", "end-1c")
-        self.text.mark_set("insert", "end-1c")
-        self.text.insert("insert", s)
-        self.text.see("insert")