def _get_nested_import_name(self):
"""
Generates an Import statement, that can be used to fake nested imports.
"""
i = self._nested_import
# This is not an existing Import statement. Therefore, set position to
# 0 (0 is not a valid line number).
zero = (0, 0)
names = [unicode(name) for name in i.namespace_names[1:]]
name = helpers.FakeName(names, self._nested_import)
new = tree.Import(i._sub_module, zero, zero, name)
new.parent = self._module
debug.dbg('Generated a nested import: %s', new)
return helpers.FakeName(str(i.namespace_names[1]), new)
def _get_names_dict(self, names_dict):
builtin_methods = {}
for cls in reversed(type(self).mro()):
try:
builtin_methods.update(cls.builtin_methods)
except AttributeError:
pass
if not builtin_methods:
return names_dict
dct = {}
for names in names_dict.values():
for name in names:
name_str = name.value
try:
method = builtin_methods[name_str, self.type]
except KeyError:
dct[name_str] = [name]
else:
parent = BuiltinMethod(self, method, name.parent)
dct[name_str] = [
helpers.FakeName(name_str, parent, is_definition=True)
]
return dct
def _module_attributes(self):
names = [
'__file__', '__package__', '__doc__', '__name__', '__version__'
]
# All the additional module attributes are strings.
parent = Instance(self._evaluator,
compiled.create(self._evaluator, str))
return [helpers.FakeName(n, parent) for n in names]
def _get_slots(self, evaluator, names_dict):
slots = names_dict['__slots__'][0]
statement = slots.parent
node = self._evaluator.eval_statement(statement)[0]
for v in node:
pos = v.start_pos
name = self._evaluator.eval_element(v)[0].obj
yield name, [helpers.FakeName(name, self, pos, True)]
def parent(self):
obj = self._value
parser_path = []
if inspect.ismodule(obj):
module = obj
else:
class FakeParent(pr.Base):
parent = None # To avoid having no parent for NamePart.
path = None
names = []
try:
o = obj.__objclass__
names.append(obj.__name__)
obj = o
except AttributeError:
pass
try:
module_name = obj.__module__
names.insert(0, obj.__name__)
except AttributeError:
# Unfortunately in some cases like `int` there's no __module__
module = builtins
else:
module = __import__(module_name)
fake_name = helpers.FakeName(names, FakeParent())
parser_path = fake_name.names
raw_module = get_module(self._value)
try:
path = module.__file__
except AttributeError:
pass
else:
path = re.sub('c$', '', path)
if path.endswith('.py'):
# cut the `c` from `.pyc`
with open(path) as f:
source = source_to_unicode(f.read())
mod = FastParser(source, path[:-1]).module
if not parser_path:
return mod
found = self._evaluator.eval_call_path(iter(parser_path), mod, None)
if found:
return found[0]
debug.warning('Interpreter lookup for Python code failed %s',
mod)
module = compiled.CompiledObject(raw_module)
if raw_module == builtins:
# The builtins module is special and always cached.
module = compiled.builtin
return compiled.create(self._evaluator, self._value, module, module)
def get_defined_names(self):
"""
Returns a list of names that define a generator, which can return the
content of a generator.
"""
executes_generator = '__next__', 'send', 'next'
for name in compiled.generator_obj.get_defined_names():
if name.name in executes_generator:
parent = GeneratorMethod(self, name.parent)
yield helpers.FakeName(name.name, parent)
else:
yield name
def names_dicts(self, search_global=False): # is always False
dct = {}
executes_generator = '__next__', 'send', 'next'
for names in compiled.generator_obj.names_dict.values():
for name in names:
if name.value in executes_generator:
parent = GeneratorMethod(self, name.parent)
dct[name.value] = [
helpers.FakeName(name.name, parent, is_definition=True)
]
else:
dct[name.value] = [name]
yield dct
def _sub_modules(self):
"""
Lists modules in the directory of this module (if this module is a
package).
"""
path = self._module.path
names = []
if path is not None and path.endswith(os.path.sep + '__init__.py'):
mods = pkgutil.iter_modules([os.path.dirname(path)])
for module_loader, name, is_pkg in mods:
name = helpers.FakeName(name)
# It's obviously a relative import to the current module.
imp = helpers.FakeImport(name, self, level=1)
name.parent = imp
names.append(name)
return names
def _sub_modules_dict(self):
"""
Lists modules in the directory of this module (if this module is a
package).
"""
path = self._module.path
names = {}
if path is not None and path.endswith(os.path.sep + '__init__.py'):
mods = pkgutil.iter_modules([os.path.dirname(path)])
for module_loader, name, is_pkg in mods:
fake_n = helpers.FakeName(name)
# It's obviously a relative import to the current module.
imp = helpers.FakeImport(fake_n, self, level=1)
fake_n.parent = imp
names[name] = [fake_n]
# TODO add something like this in the future, its cleaner than the
# import hacks.
# ``os.path`` is a hardcoded exception, because it's a
# ``sys.modules`` modification.
#if str(self.name) == 'os':
# names.append(helpers.FakeName('path', parent=self))
return names
def _generate_name(self, name):
# Create a pseudo import to be able to follow them.
name = helpers.FakeName(name)
imp = helpers.FakeImport(name, parent=self.module)
name.parent = imp
return name
def name(self):
return helpers.FakeName(unicode(self.base.name), self, (1, 0))
def name(self):
name = self.base.name
return helpers.FakeName(unicode(name), self, name.start_pos)
def _generate_name(self, name):
return helpers.FakeName(name, parent=self.module)
def name(self):
return helpers.FakeName(self.type, parent=self)
def _generate_name(self, name):
return helpers.FakeName(name, parent=self.import_stmt)
