GeezerVisonThe World Wide Web, restored to 800 pixels of glory. |
| Home|About|Gaming cabinet|Archives|How it works|Starter sites |
GeezerVison is showing github.com — bpython/bpython/autocomplete.py at master · wis/bpython Expand file tree/ Copy pathautocomplete.pyMore file actions 613 lines (489 loc) · 20.6 KB / Copy pathautocomplete.pyFile metadata and controls613 lines (489 loc) · 20.6 KB 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 # coding: utf-8 # The MIT License # # Copyright (c) 2009-2015 the bpython authors. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # from __future__ import unicode_literals, absolute_import import __main__ import abc import glob import keyword import logging import os import re import rlcompleter from six.moves import range, builtins from six import string_types, iteritems from . import inspection from . import importcompletion from . import line as lineparts from .line import LinePart from ._py3compat import py3, try_decode from .lazyre import LazyReCompile from .simpleeval import (safe_eval, evaluate_current_expression, EvaluationError) if not py3: from types import InstanceType, ClassType # Autocomplete modes SIMPLE = 'simple' SUBSTRING = 'substring' FUZZY = 'fuzzy' ALL_MODES = (SIMPLE, SUBSTRING, FUZZY) MAGIC_METHODS = tuple("__%s__" % s for s in ( "init", "repr", "str", "lt", "le", "eq", "ne", "gt", "ge", "cmp", "hash", "nonzero", "unicode", "getattr", "setattr", "get", "set", "call", "len", "getitem", "setitem", "iter", "reversed", "contains", "add", "sub", "mul", "floordiv", "mod", "divmod", "pow", "lshift", "rshift", "and", "xor", "or", "div", "truediv", "neg", "pos", "abs", "invert", "complex", "int", "float", "oct", "hex", "index", "coerce", "enter", "exit")) if py3: KEYWORDS = frozenset(keyword.kwlist) else: KEYWORDS = frozenset(name.decode('ascii') for name in keyword.kwlist) def after_last_dot(name): return name.rstrip('.').rsplit('.')[-1] def few_enough_underscores(current, match): """Returns whether match should be shown based on current if current is _, True if match starts with 0 or 1 underscore if current is __, True regardless of match otherwise True if match does not start with any underscore """ if current.startswith('__'): return True elif current.startswith('_') and not match.startswith('__'): return True elif match.startswith('_'): return False else: return True def method_match_simple(word, size, text): return word[:size] == text def method_match_substring(word, size, text): return text in word def method_match_fuzzy(word, size, text): s = r'.*%s.*' % '.*'.join(list(text)) return re.search(s, word) MODES_MAP = { SIMPLE: method_match_simple, SUBSTRING: method_match_substring, FUZZY: method_match_fuzzy } class BaseCompletionType(object): """Describes different completion types""" def __init__(self, shown_before_tab=True, mode=SIMPLE): self._shown_before_tab = shown_before_tab self.method_match = MODES_MAP[mode] def matches(self, cursor_offset, line, **kwargs): """Returns a list of possible matches given a line and cursor, or None if this completion type isn't applicable. ie, import completion doesn't make sense if there cursor isn't after an import or from statement, so it ought to return None. Completion types are used to: * `locate(cur, line)` their initial target word to replace given a line and cursor * find `matches(cur, line)` that might replace that word * `format(match)` matches to be displayed to the user * determine whether suggestions should be `shown_before_tab` * `substitute(cur, line, match)` in a match for what's found with `target` """ raise NotImplementedError def locate(self, cursor_offset, line): """Returns a Linepart namedtuple instance or None given cursor and line A Linepart namedtuple contains a start, stop, and word. None is returned if no target for this type of completion is found under the cursor.""" raise NotImplementedError def format(self, word): return word def substitute(self, cursor_offset, line, match): """Returns a cursor offset and line with match swapped in""" lpart = self.locate(cursor_offset, line) offset = lpart.start + len(match) changed_line = line[:lpart.start] + match + line[lpart.end:] return offset, changed_line @property def shown_before_tab(self): """Whether suggestions should be shown before the user hits tab, or only once that has happened.""" return self._shown_before_tab class CumulativeCompleter(BaseCompletionType): """Returns combined matches from several completers""" def __init__(self, completers, mode=SIMPLE): if not completers: raise ValueError( "CumulativeCompleter requires at least one completer") self._completers = completers super(CumulativeCompleter, self).__init__(True, mode) def locate(self, current_offset, line): return self._completers[0].locate(current_offset, line) def format(self, word): return self._completers[0].format(word) def matches(self, cursor_offset, line, **kwargs): return_value = None all_matches = set() for completer in self._completers: matches = completer.matches(cursor_offset=cursor_offset, line=line, **kwargs) if matches is not None: all_matches.update(matches) return_value = all_matches return return_value class ImportCompletion(BaseCompletionType): def matches(self, cursor_offset, line, **kwargs): return importcompletion.complete(cursor_offset, line) def locate(self, current_offset, line): return lineparts.current_word(current_offset, line) def format(self, word): return after_last_dot(word) class FilenameCompletion(BaseCompletionType): def __init__(self, mode=SIMPLE): super(FilenameCompletion, self).__init__(False, mode) if py3: def safe_glob(self, pathname): return glob.iglob(glob.escape(pathname) + '*') else: def safe_glob(self, pathname): try: return glob.glob(pathname + '*') except re.error: # see #491 return tuple() def matches(self, cursor_offset, line, **kwargs): cs = lineparts.current_string(cursor_offset, line) if cs is None: return None matches = set() username = cs.word.split(os.path.sep, 1)[0] user_dir = os.path.expanduser(username) for filename in self.safe_glob(os.path.expanduser(cs.word)): if os.path.isdir(filename): filename += os.path.sep if cs.word.startswith('~'): filename = username + filename[len(user_dir):] matches.add(filename) return matches def locate(self, current_offset, line): return lineparts.current_string(current_offset, line) def format(self, filename): filename.rstrip(os.sep).rsplit(os.sep)[-1] if os.sep in filename[:-1]: return filename[filename.rindex(os.sep, 0, -1) + 1:] else: return filename class AttrCompletion(BaseCompletionType): attr_matches_re = LazyReCompile(r"(\w+(\.\w+)*)\.(\w*)") def matches(self, cursor_offset, line, **kwargs): if 'locals_' not in kwargs: return None locals_ = kwargs['locals_'] r = self.locate(cursor_offset, line) if r is None: return None if locals_ is None: # TODO add a note about why locals_ = __main__.__dict__ assert '.' in r.word for i in range(1, len(r.word) + 1): if r.word[-i] == '[': i -= 1 break methodtext = r.word[-i:] matches = set(''.join([r.word[:-i], m]) for m in self.attr_matches(methodtext, locals_)) return set(m for m in matches if few_enough_underscores(r.word.split('.')[-1], m.split('.')[-1])) def locate(self, current_offset, line): return lineparts.current_dotted_attribute(current_offset, line) def format(self, word): return after_last_dot(word) def attr_matches(self, text, namespace): """Taken from rlcompleter.py and bent to my will. """ # Gna, Py 2.6's rlcompleter searches for __call__ inside the # instance instead of the type, so we monkeypatch to prevent # side-effects (__getattr__/__getattribute__) m = self.attr_matches_re.match(text) if not m: return [] expr, attr = m.group(1, 3) if expr.isdigit(): # Special case: float literal, using attrs here will result in # a SyntaxError return [] try: obj = safe_eval(expr, namespace) except EvaluationError: return [] with inspection.AttrCleaner(obj): matches = self.attr_lookup(obj, expr, attr) return matches def attr_lookup(self, obj, expr, attr): """Second half of original attr_matches method factored out so it can be wrapped in a safe try/finally block in case anything bad happens to restore the original __getattribute__ method.""" words = self.list_attributes(obj) if hasattr(obj, '__class__'): words.append('__class__') words = words + rlcompleter.get_class_members(obj.__class__) if not isinstance(obj.__class__, abc.ABCMeta): try: words.remove('__abstractmethods__') except ValueError: pass if not py3 and isinstance(obj, (InstanceType, ClassType)): # Account for the __dict__ in an old-style class. words.append('__dict__') matches = [] n = len(attr) for word in words: if self.method_match(word, n, attr) and word != "__builtins__": matches.append("%s.%s" % (expr, word)) return matches if py3: def list_attributes(self, obj): return dir(obj) else: def list_attributes(self, obj): if isinstance(obj, InstanceType): try: return dir(obj) except Exception: # This is a case where we can not prevent user code from # running. We return a default list attributes on error # instead. (#536) return ['__doc__', '__module__'] else: return dir(obj) class DictKeyCompletion(BaseCompletionType): def matches(self, cursor_offset, line, **kwargs): if 'locals_' not in kwargs: return None locals_ = kwargs['locals_'] r = self.locate(cursor_offset, line) if r is None: return None _, _, dexpr = lineparts.current_dict(cursor_offset, line) try: obj = safe_eval(dexpr, locals_) except EvaluationError: return None if isinstance(obj, dict) and obj.keys(): matches = set("{0!r}]".format(k) for k in obj.keys() if repr(k).startswith(r.word)) return matches if matches else None else: return None def locate(self, current_offset, line): return lineparts.current_dict_key(current_offset, line) def format(self, match): return match[:-1] class MagicMethodCompletion(BaseCompletionType): def matches(self, cursor_offset, line, **kwargs): if 'current_block' not in kwargs: return None current_block = kwargs['current_block'] r = self.locate(cursor_offset, line) if r is None: return None if 'class' not in current_block: return None return set(name for name in MAGIC_METHODS if name.startswith(r.word)) def locate(self, current_offset, line): return lineparts.current_method_definition_name(current_offset, line) class GlobalCompletion(BaseCompletionType): def matches(self, cursor_offset, line, **kwargs): """Compute matches when text is a simple name. Return a list of all keywords, built-in functions and names currently defined in self.namespace that match. """ if 'locals_' not in kwargs: return None locals_ = kwargs['locals_'] r = self.locate(cursor_offset, line) if r is None: return None matches = set() n = len(r.word) for word in KEYWORDS: if self.method_match(word, n, r.word): matches.add(word) for nspace in (builtins.__dict__, locals_): for word, val in iteritems(nspace): word = try_decode(word, 'ascii') # if identifier isn't ascii, don't complete (syntax error) if word is None: continue if (self.method_match(word, n, r.word) and word != "__builtins__"): matches.add(_callable_postfix(val, word)) return matches if matches else None def locate(self, current_offset, line): return lineparts.current_single_word(current_offset, line) class ParameterNameCompletion(BaseCompletionType): def matches(self, cursor_offset, line, **kwargs): if 'argspec' not in kwargs: return None argspec = kwargs['argspec'] if not argspec: return None r = self.locate(cursor_offset, line) if r is None: return None if argspec: matches = set(name + '=' for name in argspec[1][0] if isinstance(name, string_types) and name.startswith(r.word)) if py3: matches.update(name + '=' for name in argspec[1][4] if name.startswith(r.word)) return matches if matches else None def locate(self, current_offset, line): return lineparts.current_word(current_offset, line) class ExpressionAttributeCompletion(AttrCompletion): # could replace attr completion as a more general case with some work def locate(self, current_offset, line): return lineparts.current_expression_attribute(current_offset, line) def matches(self, cursor_offset, line, **kwargs): if 'locals_' not in kwargs: return None locals_ = kwargs['locals_'] if locals_ is None: locals_ = __main__.__dict__ attr = self.locate(cursor_offset, line) try: obj = evaluate_current_expression(cursor_offset, line, locals_) except EvaluationError: return set() with inspection.AttrCleaner(obj): # strips leading dot matches = [m[1:] for m in self.attr_lookup(obj, '', attr.word)] return set(m for m in matches if few_enough_underscores(attr.word, m)) try: import jedi except ImportError: class MultilineJediCompletion(BaseCompletionType): def matches(self, cursor_offset, line, **kwargs): return None else: class JediCompletion(BaseCompletionType): def matches(self, cursor_offset, line, **kwargs): if 'history' not in kwargs: return None history = kwargs['history'] if not lineparts.current_word(cursor_offset, line): return None history = '\n'.join(history) + '\n' + line try: script = jedi.Script(history, len(history.splitlines()), cursor_offset, 'fake.py') completions = script.completions() except (jedi.NotFoundError, IndexError, KeyError): # IndexError for #483 # KeyError for #544 self._orig_start = None return None if completions: diff = len(completions[0].name) - len(completions[0].complete) self._orig_start = cursor_offset - diff else: self._orig_start = None return None first_letter = line[self._orig_start:self._orig_start + 1] matches = [try_decode(c.name, 'ascii') for c in completions] if any(not m.lower().startswith(matches[0][0].lower()) for m in matches): # Too general - giving completions starting with multiple # letters return None else: # case-sensitive matches only return set(m for m in matches if m.startswith(first_letter)) def locate(self, cursor_offset, line): start = self._orig_start end = cursor_offset return LinePart(start, end, line[start:end]) class MultilineJediCompletion(JediCompletion): def matches(self, cursor_offset, line, **kwargs): if 'current_block' not in kwargs or 'history' not in kwargs: return None current_block = kwargs['current_block'] history = kwargs['history'] if '\n' in current_block: assert cursor_offset <= len(line), "%r %r" % (cursor_offset, line) results = super(MultilineJediCompletion, self).matches(cursor_offset, line, history=history) return results else: return None def get_completer(completers, cursor_offset, line, **kwargs): """Returns a list of matches and an applicable completer If no matches available, returns a tuple of an empty list and None cursor_offset is the current cursor column line is a string of the current line kwargs (all optional): locals_ is a dictionary of the environment argspec is an inspect.ArgSpec instance for the current function where the cursor is current_block is the possibly multiline not-yet-evaluated block of code which the current line is part of complete_magic_methods is a bool of whether we ought to complete double underscore methods like __len__ in method signatures """ for completer in completers: try: matches = completer.matches(cursor_offset, line, **kwargs) except Exception as e: # Instead of crashing the UI, log exceptions from autocompleters. logger = logging.getLogger(__name__) logger.debug( 'Completer {} failed with unhandled exception: {}'.format( completer, e)) continue if matches is not None: return sorted(matches), (completer if matches else None) return [], None def get_default_completer(mode=SIMPLE): return ( DictKeyCompletion(mode=mode), ImportCompletion(mode=mode), FilenameCompletion(mode=mode), MagicMethodCompletion(mode=mode), MultilineJediCompletion(mode=mode), CumulativeCompleter((GlobalCompletion(mode=mode), ParameterNameCompletion(mode=mode)), mode=mode), AttrCompletion(mode=mode), ExpressionAttributeCompletion(mode=mode), ) def get_completer_bpython(cursor_offset, line, **kwargs): """""" return get_completer(get_default_completer(), cursor_offset, line, **kwargs) def _callable_postfix(value, word): """rlcompleter's _callable_postfix done right.""" with inspection.AttrCleaner(value): if inspection.is_callable(value): word += '(' return word |
| You are visitor 01402520 — GeezerVison does not store the pages you look up. Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required. |