From f8e0c78f7741e3f5f2e6d804b7428103437b43e5 Mon Sep 17 00:00:00 2001 From: David Halter Date: Thu, 21 Feb 2013 22:04:35 +0430 Subject: [PATCH] Script.get_in_function_call -> Script.function_definition --- jedi/api.py | 18 +++++++++--- jedi/api_classes.py | 6 ++-- jedi/cache.py | 4 +-- jedi/settings.py | 16 +++++----- test/base.py | 4 +-- test/regression.py | 72 ++++++++++++++++++++++----------------------- 6 files changed, 66 insertions(+), 54 deletions(-) diff --git a/jedi/api.py b/jedi/api.py index 79b3c066..c3bda853 100644 --- a/jedi/api.py +++ b/jedi/api.py @@ -11,6 +11,7 @@ __all__ = ['Script', 'NotFoundError', 'set_debug_function', '_quick_complete'] import re import os +import warnings import parsing import parsing_representation as pr @@ -122,7 +123,7 @@ class Script(object): completions.append((c, s)) if not dot: # named params have no dots - call_def = self.get_in_function_call() + call_def = self.function_definition() if call_def: if not call_def.module.is_builtin(): for p in call_def.params: @@ -336,6 +337,15 @@ class Script(object): return sorted(set(names), key=lambda x: (x.module_path, x.start_pos)) def get_in_function_call(self): + """ + .. deprecated:: 0.5.0 + Use :attr:`.function_definition` instead. + .. todo:: Remove! + """ + warnings.warn("Use line instead.", DeprecationWarning) + return self.function_definition() + + def function_definition(self): """ Return the function object of the call you're currently in. @@ -391,7 +401,7 @@ class Script(object): debug.speed('func_call start') call = None - if settings.use_get_in_function_call_cache: + if settings.use_function_definition_cache: try: call, index = check_cache() except NotFoundError: @@ -405,9 +415,9 @@ class Script(object): return None debug.speed('func_call parsed') - with common.scale_speed_settings(settings.scale_get_in_function_call): + with common.scale_speed_settings(settings.scale_function_definition): _callable = lambda: evaluate.follow_call(call) - origins = cache.cache_get_in_function_call(_callable, user_stmt) + origins = cache.cache_function_definition(_callable, user_stmt) debug.speed('func_call followed') if len(origins) == 0: diff --git a/jedi/api_classes.py b/jedi/api_classes.py index 66d4db8c..35c3d76b 100644 --- a/jedi/api_classes.py +++ b/jedi/api_classes.py @@ -336,9 +336,11 @@ class RelatedName(BaseDefinition): class CallDef(object): - """ `CallDef` objects is the return value of `Script.get_in_function_call`. + """ + `CallDef` objects is the return value of `Script.function_definition`. It knows what functions you are currently in. e.g. `isinstance(` would - return the `isinstance` function. without `(` it would return nothing.""" + return the `isinstance` function. without `(` it would return nothing. + """ def __init__(self, executable, index, call): self.executable = executable self.index = index diff --git a/jedi/cache.py b/jedi/cache.py index f916beca..e60583f4 100644 --- a/jedi/cache.py +++ b/jedi/cache.py @@ -135,8 +135,8 @@ def time_cache(time_add_setting): return _temp -@time_cache("get_in_function_call_validity") -def cache_get_in_function_call(stmt): +@time_cache("function_definition_validity") +def cache_function_definition(stmt): module_path = stmt.get_parent_until().path return None if module_path is None else (module_path, stmt.start_pos) diff --git a/jedi/settings.py b/jedi/settings.py index 63c6413b..d8162170 100644 --- a/jedi/settings.py +++ b/jedi/settings.py @@ -34,7 +34,7 @@ Parser .. autodata:: fast_parser .. autodata:: fast_parser_always_reparse -.. autodata:: use_get_in_function_call_cache +.. autodata:: use_function_definition_cache Dynamic stuff @@ -66,14 +66,14 @@ definitely worse in some cases. But a completion should also be fast. .. autodata:: max_function_recursion_level .. autodata:: max_executions_without_builtins .. autodata:: max_executions -.. autodata:: scale_get_in_function_call +.. autodata:: scale_function_definition Caching ~~~~~~~ .. autodata:: star_import_cache_validity -.. autodata:: get_in_function_call_validity +.. autodata:: function_definition_validity Various @@ -156,9 +156,9 @@ This is just a debugging option. Always reparsing means that the fast parser is basically useless. So don't use it. """ -use_get_in_function_call_cache = True +use_function_definition_cache = True """ -Use the cache (full cache) to generate get_in_function_call's. This may fail +Use the cache (full cache) to generate function_definition's. This may fail with multiline docstrings (likely) and other complicated changes (unlikely). The goal is to move away from it by making the rest faster. """ @@ -225,9 +225,9 @@ max_executions = 250 A maximum amount of time, the completion may use. """ -scale_get_in_function_call = 0.1 +scale_function_definition = 0.1 """ -Because get_in_function_call is normally used on every single key hit, it has +Because function_definition is normally used on every single key hit, it has to be faster than a normal completion. This is the factor that is used to scale `max_executions` and `max_until_execution_unique`: """ @@ -253,7 +253,7 @@ might be slow, therefore we do a star import caching, that lasts a certain time span (in seconds). """ -get_in_function_call_validity = 3.0 +function_definition_validity = 3.0 """ Finding function calls might be slow (0.1-0.5s). This is not acceptible for normal writing. Therefore cache it for a short time. diff --git a/test/base.py b/test/base.py index 21ad78d7..fc78c437 100644 --- a/test/base.py +++ b/test/base.py @@ -65,9 +65,9 @@ class TestBase(unittest.TestCase): script = self.get_script(src, pos) return script.goto() - def get_in_function_call(self, src, pos=None): + def function_definition(self, src, pos=None): script = self.get_script(src, pos) - return script.get_in_function_call() + return script.function_definition() def print_summary(): print('\nSummary: (%s fails of %s tests) in %.3fs' % \ diff --git a/test/regression.py b/test/regression.py index c67c4e7a..97e9f37b 100755 --- a/test/regression.py +++ b/test/regression.py @@ -35,11 +35,11 @@ class TestRegression(TestBase): self.assertEqual(length, 1) def test_part_parser(self): - """ test the get_in_function_call speedups """ + """ test the function_definition speedups """ s = '\n' * 100 + 'abs(' pos = 101, 4 - self.get_in_function_call(s, pos) - assert self.get_in_function_call(s, pos) + self.function_definition(s, pos) + assert self.function_definition(s, pos) def test_get_definition_cursor(self): @@ -123,7 +123,7 @@ class TestRegression(TestBase): assert self.complete("from datetime import")[0].word == 'import' assert self.complete("from datetime import ") - def test_get_in_function_call(self): + def test_function_definition(self): def check(call_def, name, index): return call_def and call_def.call_name == name \ and call_def.index == index @@ -139,54 +139,54 @@ class TestRegression(TestBase): s7 = "str().upper().center(" s8 = "str(int[zip(" - assert check(self.get_in_function_call(s, (1, 4)), 'abs', 0) - assert check(self.get_in_function_call(s, (1, 6)), 'abs', 1) - assert check(self.get_in_function_call(s, (1, 7)), 'abs', 1) - assert check(self.get_in_function_call(s, (1, 8)), 'abs', 1) - assert check(self.get_in_function_call(s, (1, 11)), 'str', 0) + assert check(self.function_definition(s, (1, 4)), 'abs', 0) + assert check(self.function_definition(s, (1, 6)), 'abs', 1) + assert check(self.function_definition(s, (1, 7)), 'abs', 1) + assert check(self.function_definition(s, (1, 8)), 'abs', 1) + assert check(self.function_definition(s, (1, 11)), 'str', 0) - assert check(self.get_in_function_call(s2, (1, 4)), 'abs', 0) - assert self.get_in_function_call(s2, (1, 5)) is None - assert self.get_in_function_call(s2) is None + assert check(self.function_definition(s2, (1, 4)), 'abs', 0) + assert self.function_definition(s2, (1, 5)) is None + assert self.function_definition(s2) is None - assert self.get_in_function_call(s3, (1, 5)) is None - assert self.get_in_function_call(s3) is None + assert self.function_definition(s3, (1, 5)) is None + assert self.function_definition(s3) is None - assert self.get_in_function_call(s4, (1, 3)) is None - assert check(self.get_in_function_call(s4, (1, 4)), 'abs', 0) - assert check(self.get_in_function_call(s4, (1, 8)), 'zip', 0) - assert check(self.get_in_function_call(s4, (1, 9)), 'abs', 0) - #assert check(self.get_in_function_call(s4, (1, 10)), 'abs', 1) + assert self.function_definition(s4, (1, 3)) is None + assert check(self.function_definition(s4, (1, 4)), 'abs', 0) + assert check(self.function_definition(s4, (1, 8)), 'zip', 0) + assert check(self.function_definition(s4, (1, 9)), 'abs', 0) + #assert check(self.function_definition(s4, (1, 10)), 'abs', 1) - assert check(self.get_in_function_call(s5, (1, 4)), 'abs', 0) - assert check(self.get_in_function_call(s5, (1, 6)), 'abs', 1) + assert check(self.function_definition(s5, (1, 4)), 'abs', 0) + assert check(self.function_definition(s5, (1, 6)), 'abs', 1) - assert check(self.get_in_function_call(s6), 'center', 0) - assert check(self.get_in_function_call(s6, (1, 4)), 'str', 0) + assert check(self.function_definition(s6), 'center', 0) + assert check(self.function_definition(s6, (1, 4)), 'str', 0) - assert check(self.get_in_function_call(s7), 'center', 0) - assert check(self.get_in_function_call(s8), 'zip', 0) - assert check(self.get_in_function_call(s8, (1, 8)), 'str', 0) + assert check(self.function_definition(s7), 'center', 0) + assert check(self.function_definition(s8), 'zip', 0) + assert check(self.function_definition(s8, (1, 8)), 'str', 0) s = "import time; abc = time; abc.sleep(" - assert check(self.get_in_function_call(s), 'sleep', 0) + assert check(self.function_definition(s), 'sleep', 0) # jedi-vim #9 s = "with open(" - assert check(self.get_in_function_call(s), 'open', 0) + assert check(self.function_definition(s), 'open', 0) # jedi-vim #11 s1 = "for sorted(" - assert check(self.get_in_function_call(s1), 'sorted', 0) + assert check(self.function_definition(s1), 'sorted', 0) s2 = "for s in sorted(" - assert check(self.get_in_function_call(s2), 'sorted', 0) + assert check(self.function_definition(s2), 'sorted', 0) # jedi #57 s = "def func(alpha, beta): pass\n" \ "func(alpha='101'," - assert check(self.get_in_function_call(s, (2, 13)), 'func', 0) + assert check(self.function_definition(s, (2, 13)), 'func', 0) - def test_get_in_function_call_complex(self): + def test_function_definition_complex(self): def check(call_def, name, index): return call_def and call_def.call_name == name \ and call_def.index == index @@ -201,17 +201,17 @@ class TestRegression(TestBase): if 1: pass """ - assert check(self.get_in_function_call(s, (6, 24)), 'abc', 0) + assert check(self.function_definition(s, (6, 24)), 'abc', 0) s = """ import re def huhu(it): re.compile( return it * 2 """ - assert check(self.get_in_function_call(s, (4, 31)), 'compile', 0) + assert check(self.function_definition(s, (4, 31)), 'compile', 0) # jedi-vim #70 s = """def foo(""" - assert self.get_in_function_call(s) is None + assert self.function_definition(s) is None def test_add_dynamic_mods(self): api.settings.additional_dynamic_modules = ['dynamic.py'] @@ -389,7 +389,7 @@ class TestSpeed(TestBase): def test_scipy_speed(self): s = 'import scipy.weave; scipy.weave.inline(' script = jedi.Script(s, 1, len(s), '') - script.get_in_function_call() + script.function_definition() #print(jedi.imports.imports_processed) if __name__ == '__main__':