'__init__',

'__new__',

'__del__',

'__repr__',

'__str__',

'__lt__',

'__le__',

'__eq__',

'__ne__',

'__gt__',

'__ge__',

'__cmp__',

'__rcmp__',

'__hash__',

'__nonzero__',

'__unicode__',

# Attribute access

'__getattr__',

'__setattr__',

'__delattr__',

# New style classes

'__getattribute__',

'__call__',

# Sequence classes

'__len__',

'__getitem__',

'__setitem__',

'__delitem__',

'__iter__',

'__reversed__',

'__contains__',

'__getslice__',

'__setslice__',

'__delslice__',

# Integer like operators

'__add__',

'__sub__',

'__mul__',

'__floordiv__',

'__mod__',

'__divmod__',

'__pow__',

'__lshift__',

'__rshift__',

'__and__',

'__xor__',

'__or__',

'__div__',

'__truediv__',

'__radd__',

'__rsub__',

'__rmul__',

'__rdiv__',

'__rtruediv__',

'__rfloordiv__',

'__rmod__',

'__rdivmod__',

'__rpow__',

'__rlshift__',

'__rrshift__',

'__rand__',

'__rxor__',

'__ror__',

'__iadd__',

'__isub__',

'__imul__',

'__idiv__',

'__itruediv__',

'__ifloordiv__',

'__imod__',

'__ipow__',

'__ilshift__',

'__irshift__',

'__iand__',

'__ixor__',

'__ior__',

'__neg__',

'__pos__',

'__abs__',

'__invert__',

'__complex__',

'__int__',

'__long__',

'__float__',

'__oct__',

'__hex__',

'__index__',

'__coerce__',

# Context managers

'__enter__',

'__exit__',

lang = lang

def __init__(self):

self._properties = SilverCity.PropertySet()

self._lexer = SilverCity.find_lexer_module_by_id(

ScintillaConstants.SCLEX_PYTHON)

self._keyword_lists = [

SilverCity.WordList(python_keywords),

SilverCity.WordList(""), # hilighted identifiers

lang = lang

def __str__(self):

return "Python imports"

def eval(self, mgr):

try:

imp_prefix = tuple(self.trg.extra["imp_prefix"])

if imp_prefix:

libs = self.buf.libs

if not imp_prefix[0]:

if not imp_prefix[-1]:

# Deal with last item being empty, i.e. "from ."

imp_prefix = imp_prefix[:-1]

lookuppath = self.buf.path

while imp_prefix and not imp_prefix[0]:

lookuppath = dirname(lookuppath)

imp_prefix = imp_prefix[1:]

libs = [mgr.db.get_lang_lib(self.lang, "curdirlib",

[lookuppath])]

else:

# We use a special lib generator - that will lazily load

# additional directory libs when there are no matches found.

# This is a smart import facility - to detect imports from

# a parent directory when they are not explicitly on the

# included path list, quite common for Django and other

# Python frameworks that mangle the sys.path at runtime.

libs = PythonImportLibGenerator(mgr, self.lang,

self.buf.path, imp_prefix,

libs)

self.ctlr.set_desc("subimports of '%s'" % '.'.join(imp_prefix))

cplns = []

for lib in libs:

imports = lib.get_blob_imports(imp_prefix)

if imports:

cplns.extend(

((is_dir_import and "directory" or "module"), name)

for name, is_dir_import in imports

)

if self.trg.type == "module-members":

# Also add top-level members of the specified module.

dotted_prefix = '.'.join(imp_prefix)

if lib.has_blob(dotted_prefix):

blob = lib.get_blob(dotted_prefix)

for name in blob.names:

elem = blob.names[name]

cplns.append((elem.get(

"ilk") or elem.tag, name))

# TODO: Consider using the value of __all__

# if defined.

for e in blob:

attrs = e.get("attributes", "").split()

if "__hidden__" not in attrs:

try:

cplns += self._members_from_elem(

e, mgr)

except CodeIntelError as ex:

log.warn(

"%s (skipping members for %s)",

ex, e)

if cplns:

break

if cplns:

cplns = list(set(cplns)) # remove duplicates

else:

self.ctlr.set_desc("available imports")

all_imports = set()

for lib in self.buf.libs:

all_imports.update(lib.get_blob_imports(imp_prefix))

cplns = [((is_dir_import and "directory" or "module"), name)

for name, is_dir_import in all_imports]

if cplns:

cplns.sort(key=lambda i: i[1].upper())

self.ctlr.set_cplns(cplns)

finally:

self.ctlr.done("success")

# XXX: This function is shamelessly copy/pasted from

# tree_python.py:PythonTreeEvaluator because there was no clear

# way to reuse this shared functionality. See another XXX below, though.

def _members_from_elem(self, elem, mgr):

"""Return the appropriate set of autocomplete completions for

members = set()

if elem.tag == "import":

alias = elem.get("alias")

symbol_name = elem.get("symbol")

module_name = elem.get("module")

if symbol_name:

import_handler = mgr.citadel.import_handler_from_lang(

self.trg.lang)

try:

blob = import_handler.import_blob_name(

module_name, self.buf.libs, self.ctlr)

except:

log.warn(

"limitation in handling imports in imported modules")

raise

if symbol_name == "*": # can it be so?

for m_name, m_elem in list(blob.names.items()):

m_type = m_elem.get("ilk") or m_elem.tag

members.add((m_type, m_name))

elif symbol_name in blob.names:

symbol = blob.names[symbol_name]

member_type = (symbol.get("ilk") or symbol.tag)

members.add((member_type, alias or symbol_name))

else:

# To correctly determine the type, we'd need to

# examine all the imports of this blob, and then see

# if any of those imports match the name... which is

# better left to the tree evaluator (tree_python).

#

# For now, we just add it as an unknown type.

members.add(('unknown', alias or symbol_name))

log.info(

"could not resolve symbol %r on %r, added as 'unknown'",

symbol_name, module_name)

else:

cpln_name = alias or module_name.split('.', 1)[0]

members.add(("module", cpln_name))

else:

members.add((elem.get("ilk") or elem.tag, elem.get("name")))

ProgLangTriggerIntelMixin,

PythonCITDLExtractorMixin):

lang = lang

interpreterPrefName = "python"

extraPathsPrefName = "pythonExtraPaths"

# Used by ProgLangTriggerIntelMixin.preceding_trg_from_pos().

trg_chars = tuple(" (.")

citdl_from_literal_type = {"string": "str"}

@LazyClassAttribute

def keywords(self):

from SilverCity.Keywords import python_keywords

return python_keywords.split(" ")

def async_eval_at_trg(self, buf, trg, ctlr):

if _xpcom_:

trg = UnwrapObject(trg)

ctlr = UnwrapObject(ctlr)

ctlr.start(buf, trg)

if trg.type in ("object-members", "call-signature",

"literal-members") or \

trg.form == TRG_FORM_DEFN:

line = buf.accessor.line_from_pos(trg.pos)

if trg.type == "literal-members":

# We could leave this to citdl_expr_from_trg, but this is a

# little bit faster, since we already know the citdl expr.

citdl_expr = trg.extra.get("citdl_expr")

else:

try:

citdl_expr = self.citdl_expr_from_trg(buf, trg)

except CodeIntelError as ex:

ctlr.error(str(ex))

ctlr.done("error")

return

evalr = PythonTreeEvaluator(ctlr, buf, trg, citdl_expr, line)

buf.mgr.request_eval(evalr)

elif trg.id == (self.lang, TRG_FORM_CPLN, "local-symbols"):

line = buf.accessor.line_from_pos(trg.pos)

citdl_expr = trg.extra.get("citdl_expr")

evalr = PythonTreeEvaluator(ctlr, buf, trg, citdl_expr, line)

buf.mgr.request_eval(evalr)

elif trg.id == (self.lang, TRG_FORM_CPLN, "magic-symbols"):

symbolstype = trg.extra.get("symbolstype")

cplns = []

if symbolstype == "string":

cplns = [("variable", "__main__")]

elif symbolstype == "def":

posttext = trg.extra.get("posttext", "")

posttext = posttext.split("\n", 1)[0]

if posttext and "(" in posttext:

cplns = [(

"function", t) for t in _g_python_magic_method_names]

else:

cplns = [(

"function", t + "(self") for t in _g_python_magic_method_names]

elif symbolstype == "global":

text = trg.extra.get("text")

if text.endswith("if"):

# Add the extended name version.

cplns = [("variable", t) for t in (

"__file__", "__loader__", "__name__ == '__main__':", "__package__")]

else:

cplns = [("variable", t) for t in (

"__file__", "__loader__", "__name__", "__package__")]

ctlr.set_cplns(cplns)

ctlr.done("success")

elif trg.id == (self.lang, TRG_FORM_CPLN, "pythondoc-tags"):

# TODO: Would like a "tag" completion image name.

cplns = [("variable", t) for t in _g_pythondoc_tags]

ctlr.set_cplns(cplns)

ctlr.done("success")

elif trg.type == "available-exceptions":

evalr = PythonTreeEvaluator(ctlr, buf, trg, None, -1)

buf.mgr.request_eval(evalr)

elif trg.type in ("available-imports", "module-members"):

evalr = PythonImportsEvaluator(ctlr, buf, trg)

buf.mgr.request_eval(evalr)

else:

raise NotImplementedError("not yet implemented: completion for "

"Python '%s' trigger" % trg.name)

# Note: Python 1.5.2 does not support sys.version_info.

info_cmd = (

r"import sys;"

r"sys.stdout.write('.'.join(map(str, sys.version_info))+'\n');"

r"sys.stdout.write(sys.prefix+'\n');"

r"sys.stdout.write('\n'.join(sys.path));")

def _python_info_from_python(self, python, env):

"""Call the given Python and return:

import process

argv = [python, "-c", self.info_cmd]

log.debug("run `%s -c ...'", python)

p = process.ProcessOpen(argv, env=env.get_all_envvars(), stdin=None)

stdout, stderr = p.communicate()

stdout_lines = stdout.splitlines(0)

retval = p.returncode

if retval:

log.warn("failed to determine Python info:\n"

" path: %s\n"

" retval: %s\n"

" stdout:\n%s\n"

" stderr:\n%s\n",

python, retval, indent('\n'.join(stdout_lines)),

indent(stderr))

# We are only to rely on the first 2 digits being in the form x.y.

ver_match = re.search("([0-9]+.[0-9]+)", stdout_lines[0])

if ver_match:

ver = ver_match.group(1)

else:

ver = None

prefix = stdout_lines[1]

if sys.platform == "win32":

libdir = join(prefix, "Lib")

else:

libdir = join(prefix, "lib", "python"+ver)

sitelibdir = join(libdir, "site-packages")

sys_path = stdout_lines[2:]

return ver, prefix, libdir, sitelibdir, sys_path

def _expand_extra_dirs(self, env, extra_dirs):

return self._gen_python_import_paths_from_dirs(extra_dirs)

def _gen_python_import_paths_from_dirs(self, extra_dirs):

"""Generate all Python import paths from a given list of dirs.

for dir in extra_dirs:

if not exists(dir):

continue

yield dir

try:

for pth_path in glob(join(dir, "*.pth")):

for p in self._gen_python_import_paths_from_pth_path(pth_path):

yield p

except EnvironmentError as ex:

log.warn("error analyzing .pth files in '%s': %s", dir, ex)

def _gen_python_import_paths_from_pth_path(self, pth_path):

pth_dir = dirname(pth_path)

for line in open(pth_path, 'r'):

line = line.strip()

if line.startswith("#"): # comment line

continue

path = join(pth_dir, line)

if exists(path):

yield path

#def _extra_dirs_from_env(self, env):

# extra_dirs = set()

# for pref in env.get_all_prefs(self.extraPathsPrefName):

# if not pref:

# continue

# for path in pref:

# extra_dirs.update(d.strip() for d in path.split(os.pathsep) if exists(d.strip()))

# if extra_dirs:

# extra_dirs = set(

# self._gen_python_import_paths_from_dirs(extra_dirs)

# )

# log.debug("Python extra lib dirs: %r", extra_dirs)

# return tuple(extra_dirs)

def interpreter_from_env(self, env):

"""Returns:

# Gather information about the current python.

python = None

if env.has_pref(self.interpreterPrefName):

python = env.get_pref(self.interpreterPrefName).strip() or None

if not python or not exists(python):

import which

syspath = env.get_envvar("PATH", "")

path = [d.strip() for d in syspath.split(os.pathsep)

if d.strip()]

try:

python = which.which("python", path=path)

except which.WhichError:

pass # intentionally supressed

if python:

python = os.path.abspath(python)

return python

def python_info_from_env(self, env):

cache_key = self.lang + "-info"

info = env.cache.get(cache_key)

if info is None:

python = self.interpreter_from_env(env)

if not python:

log.warn("no Python was found from which to determine the "

"codeintel information")

info = None, None, None, None, []

else:

info = self._python_info_from_python(python, env)

env.cache[cache_key] = info

return info

def _buf_indep_libs_from_env(self, env):

"""Create the buffer-independent list of libs."""

cache_key = self.lang + "-libs"

libs = env.cache.get(cache_key)

if libs is None:

env.add_pref_observer(

self.interpreterPrefName, self._invalidate_cache)

env.add_pref_observer(self.extraPathsPrefName,

self._invalidate_cache_and_rescan_extra_dirs)

env.add_pref_observer("codeintel_selected_catalogs",

self._invalidate_cache)

db = self.mgr.db

ver, prefix, libdir, sitelibdir, sys_path \

= self.python_info_from_env(env)

libs = []

# - extradirslib

extra_dirs = self._extra_dirs_from_env(env)

if extra_dirs:

libs.append(db.get_lang_lib(self.lang, "extradirslib",

extra_dirs))

# Figure out which sys.path dirs belong to which lib.

paths_from_libname = {"sitelib": [], "envlib": [], "stdlib": []}

canon_sitelibdir = sitelibdir and normcase(sitelibdir) or None

canon_prefix = prefix and normcase(prefix) or None

canon_libdir = libdir and normcase(libdir) or None

canon_libdir_plat_prefix = libdir and normcase(

join(libdir, "plat-")) or None

canon_libdir_lib_prefix = libdir and normcase(

join(libdir, "lib-")) or None

for dir in sys_path:

STATE = "envlib"

canon_dir = normcase(dir)

if dir == "": # -> curdirlib (already handled)

continue

elif canon_dir.endswith(".zip") and isfile(dir):

log.warn("`%s': not handling .zip file on Python sys.path",

dir)

continue

elif canon_dir.endswith(".egg") and isfile(dir):

# log.warn("`%s': not handling .egg file on Python sys.path",

# dir)

continue

elif canon_dir.startswith(canon_sitelibdir):

STATE = "sitelib"

# Check against the known list of standard library locations.

elif canon_dir == canon_libdir or \

canon_dir.startswith(canon_libdir_plat_prefix) or \

canon_dir.startswith(canon_libdir_lib_prefix):

STATE = "stdlib"

if not exists(dir):

continue

paths_from_libname[STATE].append(dir)

log.debug("Python %s paths for each lib:\n%s",

ver, indent(pformat(paths_from_libname)))

# - envlib, sitelib, cataloglib, stdlib

if paths_from_libname["envlib"]:

libs.append(db.get_lang_lib(self.lang, "envlib",

paths_from_libname["envlib"]))

if paths_from_libname["sitelib"]:

libs.append(db.get_lang_lib(self.lang, "sitelib",

paths_from_libname["sitelib"]))

catalog_selections = env.get_pref("codeintel_selected_catalogs")

libs += [

db.get_catalog_lib(self.lang, catalog_selections),

db.get_stdlib(self.lang, ver)

]

env.cache[cache_key] = libs

return libs

def libs_from_buf(self, buf):

env = buf.env

# A buffer's libs depend on its env and the buf itself so

# we cache it on the env and key off the buffer.

cache_key = self.lang + "-buf-libs"

cache = env.cache.get(cache_key) # <buf-weak-ref> -> <libs>

if cache is None:

cache = weakref.WeakKeyDictionary()

env.cache[cache_key] = cache

if buf not in cache:

# - curdirlib

# Using the dirname of this buffer isn't always right, but

# hopefully is a good first approximation.

libs = []

if buf.path:

cwd = dirname(buf.path)

if cwd != "<Unsaved>":

libs = [self.mgr.db.get_lang_lib(

self.lang, "curdirlib", [cwd])]

libs += self._buf_indep_libs_from_env(env)

cache[buf] = libs

return cache[buf]

def _invalidate_cache(self, env, pref_name):

for key in (self.lang + "-buf-libs", self.lang + "-libs"):

if key in env.cache:

log.debug("invalidate '%s' cache on %r", key, env)

del env.cache[key]

def _invalidate_cache_and_rescan_extra_dirs(self, env, pref_name):

self._invalidate_cache(env, pref_name)

extra_dirs = self._extra_dirs_from_env(env)

if extra_dirs:

extradirslib = self.mgr.db.get_lang_lib(

self.lang, "extradirslib", extra_dirs)

request = PreloadLibRequest(extradirslib)

lang = lang

# Fillup chars for Python: basically, any non-identifier char.

# - remove '*' from fillup chars because: "from foo import <|>*"

cpln_fillup_chars = "~`!@#$%^&()-=+{}[]|\\;:'\",.<>?/ "

cpln_stop_chars = "~`!@#$%^&*()-=+{}[]|\\;:'\",.<>?/ "

sce_prefixes = ["SCE_P_"]

cb_show_if_empty = True

keyword_style = ScintillaConstants.SCE_P_WORD

identifier_style = ScintillaConstants.SCE_P_IDENTIFIER

@property

def libs(self):

return self.langintel.libs_from_buf(self)

def trg_from_pos(self, pos, implicit=True):

"""Python trigger types:

DEBUG = False # not using 'logging' system, because want to be fast

if DEBUG:

print("\n----- Python trg_from_pos(pos=%r, implicit=%r) -----"\

% (pos, implicit))

if pos == 0:

return None

accessor = self.accessor

last_pos = pos - 1

last_char = accessor.char_at_pos(last_pos)

if DEBUG:

print(" last_pos: %s" % last_pos)

print(" last_char: %r" % last_char)

# Quick out if the preceding char isn't a trigger char.

# Note: Cannot use this now that we have a 2-char locals trigger.

# if last_char not in " .(@_,":

# if DEBUG:

# print "trg_from_pos: no: %r is not in ' .(@'_" % last_char

# return None

style = accessor.style_at_pos(last_pos)

if DEBUG:

style_names = self.style_names_from_style_num(style)

print(" style: %s (%s)" % (style, ", ".join(style_names)))

if last_char == "@":

# Possibly python-complete-pythondoc-tags (the only trigger

# on '@').

#

# Notes:

# - PythonDoc 2.1b6 started allowing pythondoc tags in doc

# strings which we are yet supporting here.

# - Trigger in comments should only happen if the comment

# begins with the "##" pythondoc signifier. We don't

# bother checking that (PERF).

if style in self.comment_styles():

# Only trigger at start of comment line.

WHITESPACE = tuple(" \t")

SENTINEL = 20

i = last_pos-1

while i >= max(0, last_pos-SENTINEL):

ch = accessor.char_at_pos(i)

if ch == "#":

return Trigger(self.lang, TRG_FORM_CPLN,

"pythondoc-tags", pos, implicit)

elif ch in WHITESPACE:

pass

else:

return None

i -= 1

return None

# Remaing triggers should never trigger in some styles.

if (implicit and style in self.implicit_completion_skip_styles and last_char != '_'

or style in self.completion_skip_styles):

if DEBUG:

print("trg_from_pos: no: completion is suppressed "\

"in style at %s: %s (%s)"\

% (last_pos, style, ", ".join(style_names)))

return None

if last_char == " ":

# used for:

# * complete-available-imports

# * complete-module-members

# * complete-available-exceptions

# Triggering examples ('_' means a space here):

# import_ from_

# Non-triggering examples:

# from FOO import_ Ximport_

# Not bothering to support:

#; if FOO:import_ FOO;import_

# Typing a space is very common so lets have a quick out before

# doing the more correct processing:

if last_pos-1 < 0 or accessor.char_at_pos(last_pos-1) not in "etm,":

return None

working_text = accessor.text_range(max(0, last_pos-200),

last_pos)

line = self._last_logical_line(working_text).strip()

if not line:

return None

ch = line[-1]

line = line.replace('\t', ' ')

# from <|>

# import <|>

if line == "from" or line == "import":

return Trigger(self.lang, TRG_FORM_CPLN,

"available-imports", pos, implicit,

imp_prefix=())

# is it "from FOO import <|>" ?

if line.endswith(" import"):

if line.startswith('from '):

imp_prefix = tuple(line[len('from '):-len(

' import')].strip().split('.'))

return Trigger(self.lang, TRG_FORM_CPLN,

"module-members", pos, implicit,

imp_prefix=imp_prefix)

if line == "except" or line == "raise" or line.endswith((" except", " raise")):

return Trigger(self.lang, TRG_FORM_CPLN,

"available-exceptions", pos, implicit)

if ch == ',':

# is it "from FOO import BAR, <|>" ?

if line.startswith('from ') and ' import ' in line:

imp_prefix = tuple(line[len('from '):line.index(

' import')].strip().split('.'))

# Need better checks

return Trigger(self.lang, TRG_FORM_CPLN,

"module-members", pos, implicit,

imp_prefix=imp_prefix)

elif last_char == '.': # must be "complete-object-members" or None

# If the first non-whitespace character preceding the '.' in the

# same statement is an identifer character then trigger, if it

# is a ')', then _maybe_ we should trigger (yes if this is

# function call paren).

#

# Triggering examples:

# FOO. FOO . FOO; BAR.

# FOO(). FOO.BAR. FOO(BAR, BAZ.

# FOO().BAR. FOO("blah();", "blam"). FOO = {BAR.

# FOO(BAR. FOO[BAR.

# ...more cases showing possible delineation of expression

# Non-triggering examples:

# FOO..

# FOO[1]. too hard to determine sequence element types

# from FOO import (BAR.

# Not sure if want to support:

# "foo". do we want to support literals? what about

# lists? tuples? dicts?

working_text = accessor.text_range(max(0, last_pos-200),

last_pos)

line = self._last_logical_line(working_text).strip()

if line:

ch = line[-1]

if (isident(ch) or isdigit(ch) or ch in '.)'):

line = line.replace('\t', ' ')

m = _dotted_from_rx.match(line)

if m:

dots = len(m.group(1).strip())

# magic value for imp_prefix, means "from .<|>"

imp_prefix = tuple('' for i in range(dots+2))

return Trigger(self.lang, TRG_FORM_CPLN,

"available-imports", pos, implicit,

imp_prefix=imp_prefix)

elif line.startswith('from '):

if ' import ' in line:

# we're in "from FOO import BAR." territory,

# which is not a trigger

return None

# from FOO.

imp_prefix = tuple(line[len(

'from '):].strip().split('.'))

return Trigger(self.lang, TRG_FORM_CPLN,

"available-imports", pos, implicit,

imp_prefix=imp_prefix)

elif line.startswith('import '):

# import FOO.

# figure out the dotted parts of "FOO" above

imp_prefix = tuple(line[len(

'import '):].strip().split('.'))

return Trigger(self.lang, TRG_FORM_CPLN,

"available-imports", pos, implicit,

imp_prefix=imp_prefix)

else:

return Trigger(self.lang, TRG_FORM_CPLN,

"object-members", pos, implicit)

elif ch in ("\"'"):

return Trigger(self.lang, TRG_FORM_CPLN,

"literal-members", pos, implicit,

citdl_expr="str")

else:

ch = None

if DEBUG:

print("trg_from_pos: no: non-ws char preceding '.' is not "\

"an identifier char or ')': %r" % ch)

return None

elif last_char == "_":

# used for:

# * complete-magic-symbols

# Triggering examples:

# def __<|>init__

# if __<|>name__ == '__main__':

# __<|>file__

# Ensure double "__".

if last_pos-1 < 0 or accessor.char_at_pos(last_pos-1) != "_":

return None

beforeChar = None

beforeStyle = None

if last_pos-2 >= 0:

beforeChar = accessor.char_at_pos(last_pos-2)

beforeStyle = accessor.style_at_pos(last_pos-2)

if DEBUG:

print("trg_from_pos:: checking magic symbol, beforeChar: %r" % (beforeChar))

if beforeChar and beforeChar in "\"'" and beforeStyle in self.string_styles():

if DEBUG:

print("trg_from_pos:: magic-symbols - string")

return Trigger(self.lang, TRG_FORM_CPLN,

"magic-symbols", last_pos-1, implicit,

symbolstype="string")

elif beforeChar == "." and beforeStyle != style:

# Turned this off, as it interferes with regular "xxx." object

# completions.

return None

if beforeStyle == style:

# No change in styles between the characters -- abort.

return None

text = accessor.text_range(max(0, last_pos-20), last_pos-1).strip()

if beforeChar and beforeChar in " \t":

if text.endswith("def"):

posttext = accessor.text_range(pos,

min(accessor.length, pos+20)

).replace(" ", "")

if DEBUG:

print("trg_from_pos:: magic-symbols - def")

return Trigger(self.lang, TRG_FORM_CPLN,

"magic-symbols", last_pos-1, implicit,

symbolstype="def",

posttext=posttext)

if DEBUG:

print("trg_from_pos:: magic-symbols - global")

return Trigger(self.lang, TRG_FORM_CPLN,

"magic-symbols", last_pos-1, implicit,

symbolstype="global", text=text)

elif last_char == '(':

# If the first non-whitespace character preceding the '(' in the

# same statement is an identifer character then trigger calltip,

#

# Triggering examples:

# FOO. FOO ( FOO; BAR(

# FOO.BAR( FOO(BAR, BAZ( FOO = {BAR(

# FOO(BAR( FOO[BAR(

# Non-triggering examples:

# FOO()( a function call returning a callable that is

# immediately called again is too rare to bother

# with

# def foo( might be a "calltip-base-signature", but this

# trigger is not yet implemented

# import ( will be handled by complete_members

# class Foo( is an "complete-available-classes" trigger,

# but this is not yet implemented

working_text = accessor.text_range(max(0, last_pos-200), last_pos)

line = self._last_logical_line(working_text).rstrip()

if line:

ch = line[-1]

if isident(ch) or isdigit(ch):

# If this is:

# def foo(

# then this might be the (as yet unimplemented)

# "calltip-base-signature" trigger or it should not be a

# trigger point.

#

# If this is:

# class Foo(

# then this should be the (as yet unimplemented)

# "complete-available-classes" trigger.

line = line.replace('\t', ' ')

lstripped = line.lstrip()

if lstripped.startswith("def"):

if DEBUG:

print("trg_from_pos: no: point is function declaration")

elif lstripped.startswith("class") and '(' not in lstripped:

# Second test is necessary to not exclude:

# class Foo(bar(<|>

if DEBUG: