def syntax_error(buff):
start = buff.get_start_iter()
end = buff.get_end_iter()
text = buff.get_text(start, end, True)
if buff.get_tag_table().lookup("err_t") is None:
buff.create_tag("err_t", underline="error")
buff.remove_tag_by_name("err_t", start, end)
errors = Script(text).get_syntax_errors()
for e in errors:
start = buff.get_start_iter()
end = buff.get_end_iter()
lin = e.line - 1
col = e.column - 1
lin2 = e.until_line - 1
col2 = e.until_column - 1
if lin < 1:
lin = 0
if col < 1:
col = 0
if lin2 < 1:
lin2 = 0
if col2 < 1:
col2 = 0
start.set_line(lin)
end.set_line(lin2)
start.set_line_offset(col)
end.set_line_offset(col2)
buff.apply_tag_by_name("err_t", start, end)
def get_script(document):
doc_text = document.get_text(document.get_start_iter(),
document.get_end_iter(), False)
iter_cursor = document.get_iter_at_mark(document.get_insert())
linenum = iter_cursor.get_line() + 1
charnum = iter_cursor.get_line_index()
return Script(doc_text, linenum, charnum, 'py')
def test_namedtuple_list(Script):
source = dedent("""\
import collections
Cat = collections.namedtuple('Person', ['legs', u'length', 'large'])
garfield = Cat(4, '85cm', True)
garfield.l""")
result = Script(source).completions()
completions = set(r.name for r in result)
assert completions == {'legs', 'length', 'large'}
def test_namedtuple_str(letter, expected, Script):
source = dedent("""\
import collections
Person = collections.namedtuple('Person', 'name smart')
dave = Person('Dave', False)
dave.%s""") % letter
result = Script(source).completions()
completions = set(r.name for r in result)
assert completions == set(expected)
def test_nested_namedtuples(Script):
"""
From issue #730.
"""
s = Script(dedent('''
import collections
Dataset = collections.namedtuple('Dataset', ['data'])
Datasets = collections.namedtuple('Datasets', ['train'])
train_x = Datasets(train=Dataset('data_value'))
train_x.train.'''))
assert 'data' in [c.name for c in s.complete()]
def test_namedtuple_goto_definitions(Script):
source = dedent("""
from collections import namedtuple
Foo = namedtuple('Foo', 'id timestamp gps_timestamp attributes')
Foo""")
from jedi.api import Script
d1, = Script(source).goto_definitions()
assert d1.get_line_code() == "class Foo(tuple):\n"
assert d1.module_path is None
def test_namedtuple_infer(Script):
source = dedent("""
from collections import namedtuple
Foo = namedtuple('Foo', 'id timestamp gps_timestamp attributes')
Foo""")
from jedi.api import Script
d1, = Script(source).infer()
assert d1.get_line_code() == "class Foo(tuple):\n"
assert d1.module_path is None
assert d1.docstring() == 'Foo(id, timestamp, gps_timestamp, attributes)'
def fill_store(buff):
global store
text = str(
buff.get_text(buff.get_start_iter(),
buff.get_iter_at_mark(buff.get_insert()), False))
completions = None
for _ in range(5):
try:
completions = Script(text).complete()
break
except:
return
if completions is not None and len(completions) > 0:
store = [x.name for x in completions if x]
return store
def tab_suggest(buff: Gtk.TextBuffer, listore=None):
global store
text = str(
buff.get_text(buff.get_start_iter(),
buff.get_iter_at_mark(buff.get_insert()), False))
completions = None
for _ in range(5):
try:
completions = Script(text).complete()
break
except:
return
if len(completions) == 1:
com = str(completions[0].name)
text = buff.get_insert()
start_it = buff.get_start_iter()
text = str(buff.get_text(start_it, buff.get_iter_at_mark(text), False))
sp1 = text.split(' ')[-1].split('.')
it1 = buff.get_iter_at_mark(buff.get_insert())
it2 = buff.get_iter_at_mark(buff.get_insert())
lin = it1.get_line()
while 1:
_k = it1.backward_char()
if not _k:
break
#if sp1[-1] == it1.get_char():
# break
if it1.get_line() < lin:
it1.forward_char()
break
if it1.get_char().isspace():
it1.forward_char()
break
if '\n' in list(it1.get_char()):
it1.forward_char()
break
if it1.get_char() != "_" and it1.get_char().isalnum() is False:
it1.forward_char()
break
buff.delete(it1, it2)
buff.insert_at_cursor(com)
store = 0
elif completions is not None and len(completions) > 0:
store = [x.name for x in completions if x]
def d(source):
x, = Script(source).goto_definitions()
return x.name
def _get_doc(word: str, buff, line_col: tuple):
full_text = str(
buff.get_text(buff.get_start_iter(), buff.get_end_iter(), True))
sc = Script(full_text).infer(line_col[0] + 1, line_col[1])
return sc
def run(code):
defs = Script(code).infer()
return {d.name for d in defs}
def d(source):
x, = Script(source).infer()
return x.name
def get_completions(code, line, column, path=None):
with _jedi_lock:
script = Script(code, line, column, path=path)
return script.completions()
def run(code):
defs = Script(code).goto_definitions()
return {d.name for d in defs}
