logo

oasis-root

Compiled tree of Oasis Linux based on own branch at <https://hacktivis.me/git/oasis/> git clone https://anongit.hacktivis.me/git/oasis-root.git

autocomplete.py (9202B)

    

  1. """Complete either attribute names or file names.
  3. Either on demand or after a user-selected delay after a key character,
  4. pop up a list of candidates.
  5. """
  6. import __main__
  7. import keyword
  8. import os
  9. import string
  10. import sys
  12. # Two types of completions; defined here for autocomplete_w import below.
  13. ATTRS, FILES = 0, 1
  14. from idlelib import autocomplete_w
  15. from idlelib.config import idleConf
  16. from idlelib.hyperparser import HyperParser
  18. # Tuples passed to open_completions.
  19. #       EvalFunc, Complete, WantWin, Mode
  20. FORCE = True,     False,    True,    None   # Control-Space.
  21. TAB   = False,    True,     True,    None   # Tab.
  22. TRY_A = False,    False,    False,   ATTRS  # '.' for attributes.
  23. TRY_F = False,    False,    False,   FILES  # '/' in quotes for file name.
  25. # This string includes all chars that may be in an identifier.
  26. # TODO Update this here and elsewhere.
  27. ID_CHARS = string.ascii_letters + string.digits + "_"
  29. SEPS = f"{os.sep}{os.altsep if os.altsep else ''}"
  30. TRIGGERS = f".{SEPS}"
  32. class AutoComplete:
  34.     def __init__(self, editwin=None, tags=None):
  35.         self.editwin = editwin
  36.         if editwin is not None:   # not in subprocess or no-gui test
  37.             self.text = editwin.text
  38.         self.tags = tags
  39.         self.autocompletewindow = None
  40.         # id of delayed call, and the index of the text insert when
  41.         # the delayed call was issued. If _delayed_completion_id is
  42.         # None, there is no delayed call.
  43.         self._delayed_completion_id = None
  44.         self._delayed_completion_index = None
  46.     @classmethod
  47.     def reload(cls):
  48.         cls.popupwait = idleConf.GetOption(
  49.             "extensions", "AutoComplete", "popupwait", type="int", default=0)
  51.     def _make_autocomplete_window(self):  # Makes mocking easier.
  52.         return autocomplete_w.AutoCompleteWindow(self.text, tags=self.tags)
  54.     def _remove_autocomplete_window(self, event=None):
  55.         if self.autocompletewindow:
  56.             self.autocompletewindow.hide_window()
  57.             self.autocompletewindow = None
  59.     def force_open_completions_event(self, event):
  60.         "(^space) Open completion list, even if a function call is needed."
  61.         self.open_completions(FORCE)
  62.         return "break"
  64.     def autocomplete_event(self, event):
  65.         "(tab) Complete word or open list if multiple options."
  66.         if hasattr(event, "mc_state") and event.mc_state or\
  67.                 not self.text.get("insert linestart", "insert").strip():
  68.             # A modifier was pressed along with the tab or
  69.             # there is only previous whitespace on this line, so tab.
  70.             return None
  71.         if self.autocompletewindow and self.autocompletewindow.is_active():
  72.             self.autocompletewindow.complete()
  73.             return "break"
  74.         else:
  75.             opened = self.open_completions(TAB)
  76.             return "break" if opened else None
  78.     def try_open_completions_event(self, event=None):
  79.         "(./) Open completion list after pause with no movement."
  80.         lastchar = self.text.get("insert-1c")
  81.         if lastchar in TRIGGERS:
  82.             args = TRY_A if lastchar == "." else TRY_F
  83.             self._delayed_completion_index = self.text.index("insert")
  84.             if self._delayed_completion_id is not None:
  85.                 self.text.after_cancel(self._delayed_completion_id)
  86.             self._delayed_completion_id = self.text.after(
  87.                 self.popupwait, self._delayed_open_completions, args)
  89.     def _delayed_open_completions(self, args):
  90.         "Call open_completions if index unchanged."
  91.         self._delayed_completion_id = None
  92.         if self.text.index("insert") == self._delayed_completion_index:
  93.             self.open_completions(args)
  95.     def open_completions(self, args):
  96.         """Find the completions and create the AutoCompleteWindow.
  97.         Return True if successful (no syntax error or so found).
  98.         If complete is True, then if there's nothing to complete and no
  99.         start of completion, won't open completions and return False.
  100.         If mode is given, will open a completion list only in this mode.
  101.         """
  102.         evalfuncs, complete, wantwin, mode = args
  103.         # Cancel another delayed call, if it exists.
  104.         if self._delayed_completion_id is not None:
  105.             self.text.after_cancel(self._delayed_completion_id)
  106.             self._delayed_completion_id = None
  108.         hp = HyperParser(self.editwin, "insert")
  109.         curline = self.text.get("insert linestart", "insert")
  110.         i = j = len(curline)
  111.         if hp.is_in_string() and (not mode or mode==FILES):
  112.             # Find the beginning of the string.
  113.             # fetch_completions will look at the file system to determine
  114.             # whether the string value constitutes an actual file name
  115.             # XXX could consider raw strings here and unescape the string
  116.             # value if it's not raw.
  117.             self._remove_autocomplete_window()
  118.             mode = FILES
  119.             # Find last separator or string start
  120.             while i and curline[i-1] not in "'\"" + SEPS:
  121.                 i -= 1
  122.             comp_start = curline[i:j]
  123.             j = i
  124.             # Find string start
  125.             while i and curline[i-1] not in "'\"":
  126.                 i -= 1
  127.             comp_what = curline[i:j]
  128.         elif hp.is_in_code() and (not mode or mode==ATTRS):
  129.             self._remove_autocomplete_window()
  130.             mode = ATTRS
  131.             while i and (curline[i-1] in ID_CHARS or ord(curline[i-1]) > 127):
  132.                 i -= 1
  133.             comp_start = curline[i:j]
  134.             if i and curline[i-1] == '.':  # Need object with attributes.
  135.                 hp.set_index("insert-%dc" % (len(curline)-(i-1)))
  136.                 comp_what = hp.get_expression()
  137.                 if (not comp_what or
  138.                    (not evalfuncs and comp_what.find('(') != -1)):
  139.                     return None
  140.             else:
  141.                 comp_what = ""
  142.         else:
  143.             return None
  145.         if complete and not comp_what and not comp_start:
  146.             return None
  147.         comp_lists = self.fetch_completions(comp_what, mode)
  148.         if not comp_lists[0]:
  149.             return None
  150.         self.autocompletewindow = self._make_autocomplete_window()
  151.         return not self.autocompletewindow.show_window(
  152.                 comp_lists, "insert-%dc" % len(comp_start),
  153.                 complete, mode, wantwin)
  155.     def fetch_completions(self, what, mode):
  156.         """Return a pair of lists of completions for something. The first list
  157.         is a sublist of the second. Both are sorted.
  159.         If there is a Python subprocess, get the comp. list there.  Otherwise,
  160.         either fetch_completions() is running in the subprocess itself or it
  161.         was called in an IDLE EditorWindow before any script had been run.
  163.         The subprocess environment is that of the most recently run script.  If
  164.         two unrelated modules are being edited some calltips in the current
  165.         module may be inoperative if the module was not the last to run.
  166.         """
  167.         try:
  168.             rpcclt = self.editwin.flist.pyshell.interp.rpcclt
  169.         except:
  170.             rpcclt = None
  171.         if rpcclt:
  172.             return rpcclt.remotecall("exec", "get_the_completion_list",
  173.                                      (what, mode), {})
  174.         else:
  175.             if mode == ATTRS:
  176.                 if what == "":  # Main module names.
  177.                     namespace = {**__main__.__builtins__.__dict__,
  178.                                  **__main__.__dict__}
  179.                     bigl = eval("dir()", namespace)
  180.                     kwds = (s for s in keyword.kwlist
  181.                             if s not in {'True', 'False', 'None'})
  182.                     bigl.extend(kwds)
  183.                     bigl.sort()
  184.                     if "__all__" in bigl:
  185.                         smalll = sorted(eval("__all__", namespace))
  186.                     else:
  187.                         smalll = [s for s in bigl if s[:1] != '_']
  188.                 else:
  189.                     try:
  190.                         entity = self.get_entity(what)
  191.                         bigl = dir(entity)
  192.                         bigl.sort()
  193.                         if "__all__" in bigl:
  194.                             smalll = sorted(entity.__all__)
  195.                         else:
  196.                             smalll = [s for s in bigl if s[:1] != '_']
  197.                     except:
  198.                         return [], []
  200.             elif mode == FILES:
  201.                 if what == "":
  202.                     what = "."
  203.                 try:
  204.                     expandedpath = os.path.expanduser(what)
  205.                     bigl = os.listdir(expandedpath)
  206.                     bigl.sort()
  207.                     smalll = [s for s in bigl if s[:1] != '.']
  208.                 except OSError:
  209.                     return [], []
  211.             if not smalll:
  212.                 smalll = bigl
  213.             return smalll, bigl
  215.     def get_entity(self, name):
  216.         "Lookup name in a namespace spanning sys.modules and __main.dict__."
  217.         return eval(name, {**sys.modules, **__main__.__dict__})
  220. AutoComplete.reload()
  222. if __name__ == '__main__':
  223.     from unittest import main
  224.     main('idlelib.idle_test.test_autocomplete', verbosity=2)