FM / idlelib

/opt/alt/python35/lib64/python3.5/idlelib/

/opt/alt/python35/lib64/python3.5/idlelib

Name	Size	Mode	Actions
Icons/	-	0755	rm
idle_test/	-	0755	rm
__pycache__/	-	0755	rm
aboutDialog.py	6987	0644	edit dl rm
AutoComplete.py	9201	0644	edit dl rm
AutoCompleteWindow.py	17739	0644	edit dl rm
AutoExpand.py	3395	0644	edit dl rm
Bindings.py	3111	0644	edit dl rm
CallTips.py	5932	0644	edit dl rm
CallTipWindow.py	6035	0644	edit dl rm
ChangeLog	56388	0644	edit dl rm
ClassBrowser.py	6999	0644	edit dl rm
CodeContext.py	8357	0644	edit dl rm
ColorDelegator.py	10598	0644	edit dl rm
config-extensions.def	2965	0644	edit dl rm
config-highlight.def	2515	0644	edit dl rm
config-keys.def	7777	0644	edit dl rm
config-main.def	2563	0644	edit dl rm
configDialog.py	65061	0644	edit dl rm
configHandler.py	32451	0644	edit dl rm
configHelpSourceEdit.py	6817	0644	edit dl rm
configSectionNameDialog.py	4007	0644	edit dl rm
CREDITS.txt	1866	0644	edit dl rm
Debugger.py	18758	0644	edit dl rm
Delegator.py	1043	0644	edit dl rm
dynOptionMenuWidget.py	1990	0644	edit dl rm
EditorWindow.py	65595	0644	edit dl rm
extend.txt	3642	0644	edit dl rm
FileList.py	3813	0644	edit dl rm
FormatParagraph.py	7287	0644	edit dl rm
GrepDialog.py	5124	0644	edit dl rm
help.html	43411	0644	edit dl rm
help.py	10952	0644	edit dl rm
help.txt	17900	0644	edit dl rm
HISTORY.txt	10312	0644	edit dl rm
HyperParser.py	12877	0644	edit dl rm
idle.py	453	0644	edit dl rm
idle.pyw	570	0644	edit dl rm
IdleHistory.py	4052	0644	edit dl rm
idlever.py	415	0644	edit dl rm
IOBinding.py	20599	0644	edit dl rm
keybindingDialog.py	12416	0644	edit dl rm
macosxSupport.py	8684	0644	edit dl rm
MultiCall.py	18571	0644	edit dl rm
MultiStatusBar.py	1348	0644	edit dl rm
NEWS.txt	15536	0644	edit dl rm
NEWS2x.txt	27172	0644	edit dl rm
ObjectBrowser.py	3975	0644	edit dl rm
OutputWindow.py	4394	0644	edit dl rm
ParenMatch.py	6714	0644	edit dl rm
PathBrowser.py	3207	0644	edit dl rm
Percolator.py	3179	0644	edit dl rm
PyParse.py	20461	0644	edit dl rm
PyShell.py	58846	0755	edit dl rm
README.txt	7891	0644	edit dl rm
RemoteDebugger.py	12007	0644	edit dl rm
RemoteObjectBrowser.py	964	0644	edit dl rm
ReplaceDialog.py	7481	0644	edit dl rm
rpc.py	20784	0644	edit dl rm
RstripExtension.py	1050	0644	edit dl rm
run.py	13869	0644	edit dl rm
ScriptBinding.py	8061	0644	edit dl rm
ScrolledList.py	4375	0644	edit dl rm
SearchDialog.py	3127	0644	edit dl rm
SearchDialogBase.py	7009	0644	edit dl rm
SearchEngine.py	7485	0644	edit dl rm
StackViewer.py	4426	0644	edit dl rm
tabbedpages.py	18418	0644	edit dl rm
textView.py	3419	0644	edit dl rm
TODO.txt	8478	0644	edit dl rm
ToolTip.py	3173	0644	edit dl rm
TreeWidget.py	15024	0644	edit dl rm
UndoDelegator.py	10980	0644	edit dl rm
WidgetRedirector.py	6939	0644	edit dl rm
WindowList.py	2472	0644	edit dl rm
ZoomHeight.py	1300	0644	edit dl rm
__init__.py	335	0644	edit dl rm
__main__.py	159	0644	edit dl rm

Edit: /opt/alt/python35/lib64/python3.5/idlelib/AutoComplete.py (9201B)

"""AutoComplete.py - An IDLE extension for automatically completing names.

This extension can complete either attribute names or file names. It can pop
a window with all available names, for the user to select from.
"""
import os
import sys
import string

from idlelib.configHandler import idleConf

# This string includes all chars that may be in an identifier
ID_CHARS = string.ascii_letters + string.digits + "_"

# These constants represent the two different types of completions
COMPLETE_ATTRIBUTES, COMPLETE_FILES = range(1, 2+1)

from idlelib import AutoCompleteWindow
from idlelib.HyperParser import HyperParser

import __main__

SEPS = os.sep
if os.altsep:  # e.g. '/' on Windows...
    SEPS += os.altsep

class AutoComplete:

menudefs = [
        ('edit', [
            ("Show Completions", "<<force-open-completions>>"),
        ])
    ]

popupwait = idleConf.GetOption("extensions", "AutoComplete",
                                   "popupwait", type="int", default=0)

def __init__(self, editwin=None):
        self.editwin = editwin
        if editwin is None:  # subprocess and test
            return
        self.text = editwin.text
        self.autocompletewindow = None

# id of delayed call, and the index of the text insert when the delayed
        # call was issued. If _delayed_completion_id is None, there is no
        # delayed call.
        self._delayed_completion_id = None
        self._delayed_completion_index = None

def _make_autocomplete_window(self):
        return AutoCompleteWindow.AutoCompleteWindow(self.text)

def _remove_autocomplete_window(self, event=None):
        if self.autocompletewindow:
            self.autocompletewindow.hide_window()
            self.autocompletewindow = None

def force_open_completions_event(self, event):
        """Happens when the user really wants to open a completion list, even
        if a function call is needed.
        """
        self.open_completions(True, False, True)

def try_open_completions_event(self, event):
        """Happens when it would be nice to open a completion list, but not
        really necessary, for example after a dot, so function
        calls won't be made.
        """
        lastchar = self.text.get("insert-1c")
        if lastchar == ".":
            self._open_completions_later(False, False, False,
                                         COMPLETE_ATTRIBUTES)
        elif lastchar in SEPS:
            self._open_completions_later(False, False, False,
                                         COMPLETE_FILES)

def autocomplete_event(self, event):
        """Happens when the user wants to complete his word, and if necessary,
        open a completion list after that (if there is more than one
        completion)
        """
        if hasattr(event, "mc_state") and event.mc_state:
            # A modifier was pressed along with the tab, continue as usual.
            return
        if self.autocompletewindow and self.autocompletewindow.is_active():
            self.autocompletewindow.complete()
            return "break"
        else:
            opened = self.open_completions(False, True, True)
            if opened:
                return "break"

def _open_completions_later(self, *args):
        self._delayed_completion_index = self.text.index("insert")
        if self._delayed_completion_id is not None:
            self.text.after_cancel(self._delayed_completion_id)
        self._delayed_completion_id = \
            self.text.after(self.popupwait, self._delayed_open_completions,
                            *args)

def _delayed_open_completions(self, *args):
        self._delayed_completion_id = None
        if self.text.index("insert") != self._delayed_completion_index:
            return
        self.open_completions(*args)

def open_completions(self, evalfuncs, complete, userWantsWin, mode=None):
        """Find the completions and create the AutoCompleteWindow.
        Return True if successful (no syntax error or so found).
        if complete is True, then if there's nothing to complete and no
        start of completion, won't open completions and return False.
        If mode is given, will open a completion list only in this mode.
        """
        # Cancel another delayed call, if it exists.
        if self._delayed_completion_id is not None:
            self.text.after_cancel(self._delayed_completion_id)
            self._delayed_completion_id = None

hp = HyperParser(self.editwin, "insert")
        curline = self.text.get("insert linestart", "insert")
        i = j = len(curline)
        if hp.is_in_string() and (not mode or mode==COMPLETE_FILES):
            # Find the beginning of the string
            # fetch_completions will look at the file system to determine whether the
            # string value constitutes an actual file name
            # XXX could consider raw strings here and unescape the string value if it's
            # not raw.
            self._remove_autocomplete_window()
            mode = COMPLETE_FILES
            # Find last separator or string start
            while i and curline[i-1] not in "'\"" + SEPS:
                i -= 1
            comp_start = curline[i:j]
            j = i
            # Find string start
            while i and curline[i-1] not in "'\"":
                i -= 1
            comp_what = curline[i:j]
        elif hp.is_in_code() and (not mode or mode==COMPLETE_ATTRIBUTES):
            self._remove_autocomplete_window()
            mode = COMPLETE_ATTRIBUTES
            while i and (curline[i-1] in ID_CHARS or ord(curline[i-1]) > 127):
                i -= 1
            comp_start = curline[i:j]
            if i and curline[i-1] == '.':
                hp.set_index("insert-%dc" % (len(curline)-(i-1)))
                comp_what = hp.get_expression()
                if not comp_what or \
                   (not evalfuncs and comp_what.find('(') != -1):
                    return
            else:
                comp_what = ""
        else:
            return

if complete and not comp_what and not comp_start:
            return
        comp_lists = self.fetch_completions(comp_what, mode)
        if not comp_lists[0]:
            return
        self.autocompletewindow = self._make_autocomplete_window()
        return not self.autocompletewindow.show_window(
                comp_lists, "insert-%dc" % len(comp_start),
                complete, mode, userWantsWin)

def fetch_completions(self, what, mode):
        """Return a pair of lists of completions for something. The first list
        is a sublist of the second. Both are sorted.

If there is a Python subprocess, get the comp. list there.  Otherwise,
        either fetch_completions() is running in the subprocess itself or it
        was called in an IDLE EditorWindow before any script had been run.

The subprocess environment is that of the most recently run script.  If
        two unrelated modules are being edited some calltips in the current
        module may be inoperative if the module was not the last to run.
        """
        try:
            rpcclt = self.editwin.flist.pyshell.interp.rpcclt
        except:
            rpcclt = None
        if rpcclt:
            return rpcclt.remotecall("exec", "get_the_completion_list",
                                     (what, mode), {})
        else:
            if mode == COMPLETE_ATTRIBUTES:
                if what == "":
                    namespace = __main__.__dict__.copy()
                    namespace.update(__main__.__builtins__.__dict__)
                    bigl = eval("dir()", namespace)
                    bigl.sort()
                    if "__all__" in bigl:
                        smalll = sorted(eval("__all__", namespace))
                    else:
                        smalll = [s for s in bigl if s[:1] != '_']
                else:
                    try:
                        entity = self.get_entity(what)
                        bigl = dir(entity)
                        bigl.sort()
                        if "__all__" in bigl:
                            smalll = sorted(entity.__all__)
                        else:
                            smalll = [s for s in bigl if s[:1] != '_']
                    except:
                        return [], []

elif mode == COMPLETE_FILES:
                if what == "":
                    what = "."
                try:
                    expandedpath = os.path.expanduser(what)
                    bigl = os.listdir(expandedpath)
                    bigl.sort()
                    smalll = [s for s in bigl if s[:1] != '.']
                except OSError:
                    return [], []

if not smalll:
                smalll = bigl
            return smalll, bigl

def get_entity(self, name):
        """Lookup name in a namespace spanning sys.modules and __main.dict__"""
        namespace = sys.modules.copy()
        namespace.update(__main__.__dict__)
        return eval(name, namespace)

if __name__ == '__main__':
    from unittest import main
    main('idlelib.idle_test.test_autocomplete', verbosity=2)

cmd: